Remove DUX/OSF code
[openafs.git] / src / vfsck / pass2.c
1 /*
2  * Copyright (c) 1980, 1986 The Regents of the University of California.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms are permitted
6  * provided that the above copyright notice and this paragraph are
7  * duplicated in all such forms and that any documentation,
8  * advertising materials, and other materials related to such
9  * distribution and use acknowledge that the software was developed
10  * by the University of California, Berkeley.  The name of the
11  * University may not be used to endorse or promote products derived
12  * from this software without specific prior written permission.
13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16  */
17
18 #include <afsconfig.h>
19 #include <afs/param.h>
20
21 #ifdef AFS_HPUX_ENV
22 /* We need the old directory type headers (included below), so don't include
23  * the normal dirent.h, or it will conflict. */
24 # undef HAVE_DIRENT_H
25 # include <sys/inode.h>
26 # define        LONGFILENAMES   1
27 # include <sys/sysmacros.h>
28 # include <sys/ino.h>
29 # define        DIRSIZ_MACRO
30 # ifdef HAVE_USR_OLD_USR_INCLUDE_NDIR_H
31 #  include </usr/old/usr/include/ndir.h>
32 # else
33 #  include <ndir.h>
34 # endif
35 #endif
36
37 #include <roken.h>
38
39 #include <ctype.h>
40
41 #define VICE
42 #ifdef AFS_VFSINCL_ENV
43 #include <sys/vnode.h>
44 #ifdef    AFS_SUN5_ENV
45 #include <sys/fs/ufs_inode.h>
46 #include <sys/fs/ufs_fs.h>
47 #define _KERNEL
48 #include <sys/fs/ufs_fsdir.h>
49 #undef _KERNEL
50 #include <sys/fs/ufs_mount.h>
51 #else
52 #include <ufs/inode.h>
53 #include <ufs/fs.h>
54 #include <ufs/fsdir.h>
55 #endif
56 #else /* AFS_VFSINCL_ENV */
57 #include <sys/inode.h>
58 #ifndef AFS_HPUX_ENV
59 #include <sys/dir.h>
60 #endif
61 #include <sys/fs.h>
62
63 #endif /* AFS_VFSINCL_ENV */
64 #include <afs/osi_inode.h>
65
66 #include "fsck.h"
67
68 int pass2check();
69
70 pass2()
71 {
72     struct dinode *dp;
73     struct inodesc rootdesc;
74
75     memset(&rootdesc, 0, sizeof(struct inodesc));
76     rootdesc.id_type = ADDR;
77     rootdesc.id_func = pass2check;
78     rootdesc.id_number = ROOTINO;
79     pathp = pathname;
80 #if defined(ACLS) && defined(AFS_HPUX_ENV)
81     switch (statemap[ROOTINO] & STATE) {
82 #else /* no ACLS */
83     switch (statemap[ROOTINO]) {
84 #endif /* ACLS */
85
86     case USTATE:
87         pfatal("ROOT INODE UNALLOCATED");
88         if (reply("ALLOCATE") == 0)
89             errexit("");
90         if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
91             errexit("CANNOT ALLOCATE ROOT INODE\n");
92         descend(&rootdesc, ROOTINO);
93         break;
94
95     case DCLEAR:
96         pfatal("DUPS/BAD IN ROOT INODE");
97         if (reply("REALLOCATE")) {
98             freeino(ROOTINO);
99             if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
100                 errexit("CANNOT ALLOCATE ROOT INODE\n");
101             descend(&rootdesc, ROOTINO);
102             break;
103         }
104         if (reply("CONTINUE") == 0)
105             errexit("");
106         statemap[ROOTINO] = DSTATE;
107         descend(&rootdesc, ROOTINO);
108         break;
109
110 #ifdef VICE
111     case VSTATE:
112 #endif /* VICE */
113     case FSTATE:
114     case FCLEAR:
115         pfatal("ROOT INODE NOT DIRECTORY");
116         if (reply("REALLOCATE")) {
117             freeino(ROOTINO);
118             if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
119                 errexit("CANNOT ALLOCATE ROOT INODE\n");
120             descend(&rootdesc, ROOTINO);
121             break;
122         }
123         if (reply("FIX") == 0)
124             errexit("");
125         dp = ginode(ROOTINO);
126         dp->di_mode &= ~IFMT;
127         dp->di_mode |= IFDIR;
128 #ifdef  AFS_SUN5_ENV
129         dp->di_smode = dp->di_mode;
130 #endif
131         inodirty();
132 #if defined(ACLS) && defined(AFS_HPUX_ENV)
133         /*
134          * Keep any info on associated continuation inode
135          */
136         if (statemap[ROOTINO] & HASCINODE)
137             statemap[ROOTINO] = DSTATE | HASCINODE;
138         else
139             statemap[ROOTINO] = DSTATE;
140 #else /* no ACLS */
141         statemap[ROOTINO] = DSTATE;
142 #endif /* ACLS */
143         /* fall into ... */
144
145     case DSTATE:
146         descend(&rootdesc, ROOTINO);
147         break;
148
149     default:
150         errexit("BAD STATE %d FOR ROOT INODE", statemap[ROOTINO]);
151     }
152 }
153
154 pass2check(idesc)
155      struct inodesc *idesc;
156 {
157     struct direct *dirp = idesc->id_dirp;
158     char *curpathloc;
159     int n, entrysize, ret = 0;
160     struct dinode *dp;
161     struct direct proto;
162     char namebuf[BUFSIZ];
163 #if defined(ACLS) && defined(AFS_HPUX_ENV)
164     int holdstate;
165 #endif /* ACLS */
166
167     /*
168      * check for "."
169      */
170     if (idesc->id_entryno != 0)
171         goto chk1;
172     if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
173         if (dirp->d_ino != idesc->id_number) {
174             direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
175             dirp->d_ino = idesc->id_number;
176             if (reply("FIX") == 1)
177                 ret |= ALTERED;
178         }
179         goto chk1;
180     }
181     direrror(idesc->id_number, "MISSING '.'");
182     proto.d_ino = idesc->id_number;
183     proto.d_namlen = 1;
184     (void)strcpy(proto.d_name, ".");
185     entrysize = DIRSIZ(&proto);
186     if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
187         pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
188                dirp->d_name);
189 #if     defined(AFS_SUN_ENV)
190         iscorrupt = 1;
191 #endif
192     } else if (dirp->d_reclen < entrysize) {
193         pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
194 #if     defined(AFS_SUN_ENV)
195         iscorrupt = 1;
196 #endif
197     } else if (dirp->d_reclen < 2 * entrysize) {
198         proto.d_reclen = dirp->d_reclen;
199         memcpy((char *)dirp, (char *)&proto, entrysize);
200         if (reply("FIX") == 1)
201             ret |= ALTERED;
202     } else {
203         n = dirp->d_reclen - entrysize;
204         proto.d_reclen = entrysize;
205         memcpy((char *)dirp, (char *)&proto, entrysize);
206         idesc->id_entryno++;
207         lncntp[dirp->d_ino]--;
208         dirp = (struct direct *)((char *)(dirp) + entrysize);
209         memset(dirp, 0, n);
210         dirp->d_reclen = n;
211         if (reply("FIX") == 1)
212             ret |= ALTERED;
213     }
214   chk1:
215     if (idesc->id_entryno > 1)
216         goto chk2;
217     proto.d_ino = idesc->id_parent;
218     proto.d_namlen = 2;
219     (void)strcpy(proto.d_name, "..");
220     entrysize = DIRSIZ(&proto);
221     if (idesc->id_entryno == 0) {
222         n = DIRSIZ(dirp);
223         if (dirp->d_reclen < n + entrysize)
224             goto chk2;
225         proto.d_reclen = dirp->d_reclen - n;
226         dirp->d_reclen = n;
227         idesc->id_entryno++;
228         lncntp[dirp->d_ino]--;
229         dirp = (struct direct *)((char *)(dirp) + n);
230         memset(dirp, 0, n);
231         dirp->d_reclen = n;
232     }
233     if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
234         if (dirp->d_ino != idesc->id_parent) {
235             direrror(idesc->id_number, "BAD INODE NUMBER FOR '..'");
236             dirp->d_ino = idesc->id_parent;
237             if (reply("FIX") == 1)
238                 ret |= ALTERED;
239         }
240         goto chk2;
241     }
242     direrror(idesc->id_number, "MISSING '..'");
243     if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
244         pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
245                dirp->d_name);
246 #if     defined(AFS_SUN_ENV)
247         iscorrupt = 1;
248 #endif
249     } else if (dirp->d_reclen < entrysize) {
250         pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
251 #if     defined(AFS_SUN_ENV)
252         iscorrupt = 1;
253 #endif
254     } else {
255         proto.d_reclen = dirp->d_reclen;
256         memcpy((char *)dirp, (char *)&proto, entrysize);
257         if (reply("FIX") == 1)
258             ret |= ALTERED;
259     }
260   chk2:
261     if (dirp->d_ino == 0)
262         return (ret | KEEPON);
263     if (dirp->d_namlen <= 2 && dirp->d_name[0] == '.'
264         && idesc->id_entryno >= 2) {
265         if (dirp->d_namlen == 1) {
266             direrror(idesc->id_number, "EXTRA '.' ENTRY");
267             dirp->d_ino = 0;
268             if (reply("FIX") == 1)
269                 ret |= ALTERED;
270             return (KEEPON | ret);
271         }
272         if (dirp->d_name[1] == '.') {
273             direrror(idesc->id_number, "EXTRA '..' ENTRY");
274             dirp->d_ino = 0;
275             if (reply("FIX") == 1)
276                 ret |= ALTERED;
277             return (KEEPON | ret);
278         }
279     }
280     curpathloc = pathp;
281     *pathp++ = '/';
282     if (pathp + dirp->d_namlen >= endpathname) {
283         *pathp = '\0';
284         errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
285     }
286     memcpy(pathp, dirp->d_name, (int)dirp->d_namlen + 1);
287     pathp += dirp->d_namlen;
288     idesc->id_entryno++;
289     n = 0;
290     if (dirp->d_ino > maxino || dirp->d_ino <= 0) {
291         direrror(dirp->d_ino, "I OUT OF RANGE");
292         n = reply("REMOVE");
293     } else {
294       again:
295 #if defined(ACLS) && defined(AFS_HPUX_ENV)
296         switch (statemap[dirp->d_ino] & STATE) {
297 #else /* no ACLS */
298         switch (statemap[dirp->d_ino]) {
299 #endif /* ACLS */
300         case USTATE:
301             direrror(dirp->d_ino, "UNALLOCATED");
302             n = reply("REMOVE");
303             break;
304
305         case DCLEAR:
306         case FCLEAR:
307             direrror(dirp->d_ino, "DUP/BAD");
308             if ((n = reply("REMOVE")) == 1)
309                 break;
310             dp = ginode(dirp->d_ino);
311 #ifdef VICE
312 #if defined(ACLS) && defined(AFS_HPUX_ENV)
313             holdstate =
314                 (dp->di_mode & IFMT) ==
315                 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
316             if (statemap[dirp->d_ino] & HASCINODE)
317                 statemap[dirp->d_ino] = holdstate | HASCINODE;
318             else
319                 statemap[dirp->d_ino] = holdstate;
320 #else
321             statemap[dirp->d_ino] =
322                 (dp->di_mode & IFMT) ==
323                 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
324 #endif
325 #else /* VICE */
326 #if defined(ACLS) && defined(AFS_HPUX_ENV)
327             holdstate = (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
328             if (statemap[dirp->d_ino] & HASCINODE)
329                 statemap[dirp->d_ino] = holdstate | HASCINODE;
330             else
331                 statemap[dirp->d_ino] = holdstate;
332 #else
333             statemap[dirp->d_ino] =
334                 (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
335 #endif
336 #endif /* VICE */
337             lncntp[dirp->d_ino] = dp->di_nlink;
338             goto again;
339
340         case DFOUND:
341             if (idesc->id_entryno > 2) {
342                 getpathname(namebuf, dirp->d_ino, dirp->d_ino);
343                 pwarn("%s %s %s\n", pathname,
344                       "IS AN EXTRANEOUS HARD LINK TO DIRECTORY", namebuf);
345                 if (preen)
346                     printf(" (IGNORED)\n");
347                 else if ((n = reply("REMOVE")) == 1)
348                     break;
349             }
350             /* fall through */
351
352         case FSTATE:
353 #ifdef VICE
354           filecase:
355 #endif /* VICE */
356             lncntp[dirp->d_ino]--;
357             break;
358
359 #ifdef VICE
360         case VSTATE:
361             direrror(dirp->d_ino, "VICE INODE REFERENCED BY DIRECTORY");
362             if (reply("CONVERT TO REGULAR FILE") != 1)
363                 break;
364             if ((dp = ginode(dirp->d_ino)) == NULL)
365                 break;
366             CLEAR_DVICEMAGIC(dp);
367             inodirty();
368             statemap[dirp->d_ino] = FSTATE;
369             ret |= ALTERED;
370             goto filecase;
371 #endif /* VICE */
372
373
374         case DSTATE:
375             descend(idesc, dirp->d_ino);
376             if (statemap[dirp->d_ino] == DFOUND) {
377                 lncntp[dirp->d_ino]--;
378             } else if (statemap[dirp->d_ino] == DCLEAR) {
379                 dirp->d_ino = 0;
380                 ret |= ALTERED;
381             } else
382                 errexit("BAD RETURN STATE %d FROM DESCEND",
383                         statemap[dirp->d_ino]);
384             break;
385
386 #if defined(ACLS) && defined(AFS_HPUX_ENV)
387             /* hpux has more dynamic states (CSTATE, CRSTATE) */
388         case CSTATE:
389             break;
390         case CRSTATE:
391             break;
392 #endif
393         default:
394             errexit("BAD STATE %d FOR INODE I=%d", statemap[dirp->d_ino],
395                     dirp->d_ino);
396         }
397     }
398     pathp = curpathloc;
399     *pathp = '\0';
400     if (n == 0)
401         return (ret | KEEPON);
402     dirp->d_ino = 0;
403     return (ret | KEEPON | ALTERED);
404 }