2 * Copyright (c) 1980, 1986 The Regents of the University of California.
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.
18 #include <afsconfig.h>
19 #include <afs/param.h>
24 #include <sys/param.h>
26 #include <sys/vnode.h>
27 #include <sys/mount.h>
28 #include <ufs/inode.h>
36 #else /* AFS_OSF_ENV */
37 #ifdef AFS_VFSINCL_ENV
38 #include <sys/vnode.h>
42 #include <sys/fs/ufs_inode.h>
43 #include <sys/fs/ufs_fs.h>
45 #include <sys/fs/ufs_fsdir.h>
47 #include <sys/fs/ufs_mount.h>
49 #include <ufs/inode.h>
51 #include <ufs/fsdir.h>
53 #else /* AFS_VFSINCL_ENV */
54 #include <sys/inode.h>
57 #define LONGFILENAMES 1
58 #include <sys/sysmacros.h>
61 #ifdef HAVE_USR_OLD_USR_INCLUDE_NDIR_H
62 #include </usr/old/usr/include/ndir.h>
71 #endif /* AFS_VFSINCL_ENV */
72 #endif /* AFS_OSF_ENV */
73 #include <afs/osi_inode.h>
86 register struct dinode *dp;
87 struct inodesc rootdesc;
89 memset((char *)&rootdesc, 0, sizeof(struct inodesc));
90 rootdesc.id_type = ADDR;
91 rootdesc.id_func = pass2check;
92 rootdesc.id_number = ROOTINO;
94 #if defined(ACLS) && defined(AFS_HPUX_ENV)
95 switch (statemap[ROOTINO] & STATE) {
97 switch (statemap[ROOTINO]) {
101 pfatal("ROOT INODE UNALLOCATED");
102 if (reply("ALLOCATE") == 0)
104 if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
105 errexit("CANNOT ALLOCATE ROOT INODE\n");
106 descend(&rootdesc, ROOTINO);
110 pfatal("DUPS/BAD IN ROOT INODE");
111 if (reply("REALLOCATE")) {
113 if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
114 errexit("CANNOT ALLOCATE ROOT INODE\n");
115 descend(&rootdesc, ROOTINO);
118 if (reply("CONTINUE") == 0)
120 statemap[ROOTINO] = DSTATE;
121 descend(&rootdesc, ROOTINO);
129 pfatal("ROOT INODE NOT DIRECTORY");
130 if (reply("REALLOCATE")) {
132 if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
133 errexit("CANNOT ALLOCATE ROOT INODE\n");
134 descend(&rootdesc, ROOTINO);
137 if (reply("FIX") == 0)
139 dp = ginode(ROOTINO);
140 dp->di_mode &= ~IFMT;
141 dp->di_mode |= IFDIR;
143 dp->di_smode = dp->di_mode;
146 #if defined(ACLS) && defined(AFS_HPUX_ENV)
148 * Keep any info on associated continuation inode
150 if (statemap[ROOTINO] & HASCINODE)
151 statemap[ROOTINO] = DSTATE | HASCINODE;
153 statemap[ROOTINO] = DSTATE;
155 statemap[ROOTINO] = DSTATE;
160 descend(&rootdesc, ROOTINO);
164 errexit("BAD STATE %d FOR ROOT INODE", statemap[ROOTINO]);
169 struct inodesc *idesc;
171 register struct direct *dirp = idesc->id_dirp;
173 int n, entrysize, ret = 0;
176 char namebuf[BUFSIZ];
177 #if defined(ACLS) && defined(AFS_HPUX_ENV)
184 if (idesc->id_entryno != 0)
186 if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
187 if (dirp->d_ino != idesc->id_number) {
188 direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
189 dirp->d_ino = idesc->id_number;
190 if (reply("FIX") == 1)
195 direrror(idesc->id_number, "MISSING '.'");
196 proto.d_ino = idesc->id_number;
198 (void)strcpy(proto.d_name, ".");
199 entrysize = DIRSIZ(&proto);
200 if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
201 pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
203 #if defined(AFS_SUN_ENV)
206 } else if (dirp->d_reclen < entrysize) {
207 pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
208 #if defined(AFS_SUN_ENV)
211 } else if (dirp->d_reclen < 2 * entrysize) {
212 proto.d_reclen = dirp->d_reclen;
213 memcpy((char *)dirp, (char *)&proto, entrysize);
214 if (reply("FIX") == 1)
217 n = dirp->d_reclen - entrysize;
218 proto.d_reclen = entrysize;
219 memcpy((char *)dirp, (char *)&proto, entrysize);
221 lncntp[dirp->d_ino]--;
222 dirp = (struct direct *)((char *)(dirp) + entrysize);
223 memset((char *)dirp, 0, n);
225 if (reply("FIX") == 1)
229 if (idesc->id_entryno > 1)
231 proto.d_ino = idesc->id_parent;
233 (void)strcpy(proto.d_name, "..");
234 entrysize = DIRSIZ(&proto);
235 if (idesc->id_entryno == 0) {
237 if (dirp->d_reclen < n + entrysize)
239 proto.d_reclen = dirp->d_reclen - n;
242 lncntp[dirp->d_ino]--;
243 dirp = (struct direct *)((char *)(dirp) + n);
244 memset((char *)dirp, 0, n);
247 if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
248 if (dirp->d_ino != idesc->id_parent) {
249 direrror(idesc->id_number, "BAD INODE NUMBER FOR '..'");
250 dirp->d_ino = idesc->id_parent;
251 if (reply("FIX") == 1)
256 direrror(idesc->id_number, "MISSING '..'");
257 if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
258 pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
260 #if defined(AFS_SUN_ENV)
263 } else if (dirp->d_reclen < entrysize) {
264 pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
265 #if defined(AFS_SUN_ENV)
269 proto.d_reclen = dirp->d_reclen;
270 memcpy((char *)dirp, (char *)&proto, entrysize);
271 if (reply("FIX") == 1)
275 if (dirp->d_ino == 0)
276 return (ret | KEEPON);
277 if (dirp->d_namlen <= 2 && dirp->d_name[0] == '.'
278 && idesc->id_entryno >= 2) {
279 if (dirp->d_namlen == 1) {
280 direrror(idesc->id_number, "EXTRA '.' ENTRY");
282 if (reply("FIX") == 1)
284 return (KEEPON | ret);
286 if (dirp->d_name[1] == '.') {
287 direrror(idesc->id_number, "EXTRA '..' ENTRY");
289 if (reply("FIX") == 1)
291 return (KEEPON | ret);
296 if (pathp + dirp->d_namlen >= endpathname) {
298 errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
300 memcpy(pathp, dirp->d_name, (int)dirp->d_namlen + 1);
301 pathp += dirp->d_namlen;
304 if (dirp->d_ino > maxino || dirp->d_ino <= 0) {
305 direrror(dirp->d_ino, "I OUT OF RANGE");
309 #if defined(ACLS) && defined(AFS_HPUX_ENV)
310 switch (statemap[dirp->d_ino] & STATE) {
312 switch (statemap[dirp->d_ino]) {
315 direrror(dirp->d_ino, "UNALLOCATED");
321 direrror(dirp->d_ino, "DUP/BAD");
322 if ((n = reply("REMOVE")) == 1)
324 dp = ginode(dirp->d_ino);
326 #if defined(ACLS) && defined(AFS_HPUX_ENV)
328 (dp->di_mode & IFMT) ==
329 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
330 if (statemap[dirp->d_ino] & HASCINODE)
331 statemap[dirp->d_ino] = holdstate | HASCINODE;
333 statemap[dirp->d_ino] = holdstate;
335 statemap[dirp->d_ino] =
336 (dp->di_mode & IFMT) ==
337 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
340 #if defined(ACLS) && defined(AFS_HPUX_ENV)
341 holdstate = (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
342 if (statemap[dirp->d_ino] & HASCINODE)
343 statemap[dirp->d_ino] = holdstate | HASCINODE;
345 statemap[dirp->d_ino] = holdstate;
347 statemap[dirp->d_ino] =
348 (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
351 lncntp[dirp->d_ino] = dp->di_nlink;
355 if (idesc->id_entryno > 2) {
356 getpathname(namebuf, dirp->d_ino, dirp->d_ino);
357 pwarn("%s %s %s\n", pathname,
358 "IS AN EXTRANEOUS HARD LINK TO DIRECTORY", namebuf);
360 printf(" (IGNORED)\n");
361 else if ((n = reply("REMOVE")) == 1)
370 lncntp[dirp->d_ino]--;
375 direrror(dirp->d_ino, "VICE INODE REFERENCED BY DIRECTORY");
376 if (reply("CONVERT TO REGULAR FILE") != 1)
378 if ((dp = ginode(dirp->d_ino)) == NULL)
380 #if defined(AFS_SUN_ENV) && !defined(AFS_SUN56_ENV)
381 dp->di_gen = dp->di_ic.ic_flags = dp->di_ic.ic_size.val[0] = 0;
383 CLEAR_DVICEMAGIC(dp);
386 statemap[dirp->d_ino] = FSTATE;
393 descend(idesc, dirp->d_ino);
394 if (statemap[dirp->d_ino] == DFOUND) {
395 lncntp[dirp->d_ino]--;
396 } else if (statemap[dirp->d_ino] == DCLEAR) {
400 errexit("BAD RETURN STATE %d FROM DESCEND",
401 statemap[dirp->d_ino]);
404 #if defined(ACLS) && defined(AFS_HPUX_ENV)
405 /* hpux has more dynamic states (CSTATE, CRSTATE) */
412 errexit("BAD STATE %d FOR INODE I=%d", statemap[dirp->d_ino],
419 return (ret | KEEPON);
421 return (ret | KEEPON | ALTERED);