![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to paxdir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / pax|
Return to paxdir.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / pax |
1.1 ! root 1: /* ! 2: opendir -- open a directory stream ! 3: ! 4: last edit: 16-Jun-1987 D A Gwyn ! 5: */ ! 6: ! 7: #include <sys/errno.h> ! 8: #include <sys/types.h> ! 9: #include <sys/stat.h> ! 10: #include "paxdir.h" ! 11: ! 12: #ifdef BSD_SYSV ! 13: /* ! 14: <sys/_dir.h> -- definitions for 4.2,4.3BSD directories ! 15: ! 16: last edit: 25-Apr-1987 D A Gwyn ! 17: ! 18: A directory consists of some number of blocks of DIRBLKSIZ bytes each, ! 19: where DIRBLKSIZ is chosen such that it can be transferred to disk in a ! 20: single atomic operation (e.g., 512 bytes on most machines). ! 21: ! 22: Each DIRBLKSIZ-byte block contains some number of directory entry ! 23: structures, which are of variable length. Each directory entry has the ! 24: beginning of a (struct direct) at the front of it, containing its ! 25: filesystem-unique ident number, the length of the entry, and the length ! 26: of the name contained in the entry. These are followed by the NUL- ! 27: terminated name padded to a (long) boundary with 0 bytes. The maximum ! 28: length of a name in a directory is MAXNAMELEN. ! 29: ! 30: The macro DIRSIZ(dp) gives the amount of space required to represent a ! 31: directory entry. Free space in a directory is represented by entries ! 32: that have dp->d_reclen > DIRSIZ(dp). All DIRBLKSIZ bytes in a ! 33: directory block are claimed by the directory entries; this usually ! 34: results in the last entry in a directory having a large dp->d_reclen. ! 35: When entries are deleted from a directory, the space is returned to the ! 36: previous entry in the same directory block by increasing its ! 37: dp->d_reclen. If the first entry of a directory block is free, then ! 38: its dp->d_fileno is set to 0; entries other than the first in a ! 39: directory do not normally have dp->d_fileno set to 0. ! 40: ! 41: prerequisite: <sys/types.h> ! 42: */ ! 43: ! 44: #if defined(accel) || defined(sun) || defined(vax) ! 45: #define DIRBLKSIZ 512 /* size of directory block */ ! 46: #else ! 47: #ifdef alliant ! 48: #define DIRBLKSIZ 4096 /* size of directory block */ ! 49: #else ! 50: #ifdef gould ! 51: #define DIRBLKSIZ 1024 /* size of directory block */ ! 52: #else ! 53: #ifdef ns32000 /* Dynix System V */ ! 54: #define DIRBLKSIZ 2600 /* size of directory block */ ! 55: #else /* be conservative; multiple blocks are okay ! 56: * but fractions are not */ ! 57: #define DIRBLKSIZ 4096 /* size of directory block */ ! 58: #endif ! 59: #endif ! 60: #endif ! 61: #endif ! 62: ! 63: #define MAXNAMELEN 255 /* maximum filename length */ ! 64: /* NOTE: not MAXNAMLEN, which has been preempted by SVR3 <dirent.h> */ ! 65: ! 66: struct direct { /* data from read()/_getdirentries() */ ! 67: unsigned long d_fileno; /* unique ident of entry */ ! 68: unsigned short d_reclen; /* length of this record */ ! 69: unsigned short d_namlen; /* length of string in d_name */ ! 70: char d_name[MAXNAMELEN + 1]; /* NUL-terminated filename */ ! 71: }; ! 72: ! 73: /* ! 74: The DIRSIZ macro gives the minimum record length which will hold the ! 75: directory entry. This requires the amount of space in a (struct ! 76: direct) without the d_name field, plus enough space for the name with a ! 77: terminating NUL character, rounded up to a (long) boundary. ! 78: ! 79: (Note that Berkeley didn't properly compensate for struct padding, ! 80: but we nevertheless have to use the same size as the actual system.) ! 81: */ ! 82: ! 83: #define DIRSIZ( dp ) ((sizeof(struct direct) - (MAXNAMELEN+1) \ ! 84: + sizeof(long) + (dp)->d_namlen) \ ! 85: / sizeof(long) * sizeof(long)) ! 86: ! 87: #else ! 88: #include <sys/dir.h> ! 89: #ifdef SYSV3 ! 90: #undef MAXNAMLEN /* avoid conflict with SVR3 */ ! 91: #endif ! 92: /* Good thing we don't need to use the DIRSIZ() macro! */ ! 93: #ifdef d_ino /* 4.3BSD/NFS using d_fileno */ ! 94: #undef d_ino /* (not absolutely necessary) */ ! 95: #else ! 96: #define d_fileno d_ino /* (struct direct) member */ ! 97: #endif ! 98: #endif ! 99: #ifdef UNK ! 100: #ifndef UFS ! 101: #include "***** ERROR ***** UNK applies only to UFS" ! 102: /* One could do something similar for getdirentries(), but I didn't bother. */ ! 103: #endif ! 104: #include <signal.h> ! 105: #endif ! 106: ! 107: #if defined(UFS) + defined(BFS) + defined(NFS) != 1 /* sanity check */ ! 108: #include "***** ERROR ***** exactly one of UFS, BFS, or NFS must be defined" ! 109: #endif ! 110: ! 111: #ifdef UFS ! 112: #define RecLen( dp ) (sizeof(struct direct)) /* fixed-length entries */ ! 113: #else /* BFS || NFS */ ! 114: #define RecLen( dp ) ((dp)->d_reclen) /* variable-length entries */ ! 115: #endif ! 116: ! 117: #ifdef NFS ! 118: #ifdef BSD_SYSV ! 119: #define getdirentries _getdirentries /* package hides this system call */ ! 120: #endif ! 121: extern int getdirentries(); ! 122: static long dummy; /* getdirentries() needs basep */ ! 123: #define GetBlock( fd, buf, n ) getdirentries( fd, buf, (unsigned)n, &dummy ) ! 124: #else /* UFS || BFS */ ! 125: #ifdef BSD_SYSV ! 126: #define read _read /* avoid emulation overhead */ ! 127: #endif ! 128: extern int read(); ! 129: #define GetBlock( fd, buf, n ) read( fd, buf, (unsigned)n ) ! 130: #endif ! 131: ! 132: #ifdef UNK ! 133: extern int _getdents(); /* actual system call */ ! 134: #endif ! 135: ! 136: extern char *strncpy(); ! 137: extern int fstat(); ! 138: extern OFFSET lseek(); ! 139: ! 140: extern int errno; ! 141: ! 142: #ifndef DIRBLKSIZ ! 143: #define DIRBLKSIZ 4096 /* directory file read buffer size */ ! 144: #endif ! 145: ! 146: #ifndef NULL ! 147: #define NULL 0 ! 148: #endif ! 149: ! 150: #ifndef SEEK_CUR ! 151: #define SEEK_CUR 1 ! 152: #endif ! 153: ! 154: #ifndef S_ISDIR /* macro to test for directory file */ ! 155: #define S_ISDIR( mode ) (((mode) & S_IFMT) == S_IFDIR) ! 156: #endif ! 157: ! 158: ! 159: #ifndef SEEK_CUR ! 160: #define SEEK_CUR 1 ! 161: #endif ! 162: ! 163: #ifdef BSD_SYSV ! 164: #define open _open /* avoid emulation overhead */ ! 165: #endif ! 166: ! 167: extern int getdents(); /* SVR3 system call, or emulation */ ! 168: ! 169: typedef char *pointer; /* (void *) if you have it */ ! 170: ! 171: extern void free(); ! 172: extern pointer malloc(); ! 173: extern int ! 174: open(), close(), fstat(); ! 175: ! 176: extern int errno; ! 177: extern OFFSET lseek(); ! 178: ! 179: #ifndef SEEK_SET ! 180: #define SEEK_SET 0 ! 181: #endif ! 182: ! 183: typedef int bool; /* Boolean data type */ ! 184: #define false 0 ! 185: #define true 1 ! 186: ! 187: ! 188: #ifndef NULL ! 189: #define NULL 0 ! 190: #endif ! 191: ! 192: #ifndef O_RDONLY ! 193: #define O_RDONLY 0 ! 194: #endif ! 195: ! 196: #ifndef S_ISDIR /* macro to test for directory file */ ! 197: #define S_ISDIR( mode ) (((mode) & S_IFMT) == S_IFDIR) ! 198: #endif ! 199: ! 200: #if __STDC__ ! 201: ! 202: DIR *opendir(char *dirname) ! 203: ! 204: #else ! 205: ! 206: DIR *opendir(dirname) ! 207: char *dirname; /* name of directory */ ! 208: ! 209: #endif ! 210: { ! 211: register DIR *dirp; /* -> malloc'ed storage */ ! 212: register int fd; /* file descriptor for read */ ! 213: struct stat sbuf; /* result of fstat() */ ! 214: ! 215: if ((fd = open(dirname, O_RDONLY)) < 0) ! 216: return NULL; /* errno set by open() */ ! 217: ! 218: if (fstat(fd, &sbuf) != 0 || !S_ISDIR(sbuf.st_mode)) { ! 219: close(fd); ! 220: errno = ENOTDIR; ! 221: return NULL; /* not a directory */ ! 222: } ! 223: if ((dirp = (DIR *) malloc(sizeof(DIR))) == NULL ! 224: || (dirp->dd_buf = (char *) malloc((unsigned) DIRBUF)) == NULL ! 225: ) { ! 226: register int serrno = errno; ! 227: /* errno set to ENOMEM by sbrk() */ ! 228: ! 229: if (dirp != NULL) ! 230: free((pointer) dirp); ! 231: ! 232: close(fd); ! 233: errno = serrno; ! 234: return NULL; /* not enough memory */ ! 235: } ! 236: dirp->dd_fd = fd; ! 237: dirp->dd_loc = dirp->dd_size = 0; /* refill needed */ ! 238: ! 239: return dirp; ! 240: } ! 241: ! 242: ! 243: /* ! 244: * closedir -- close a directory stream ! 245: * ! 246: * last edit: 11-Nov-1988 D A Gwyn ! 247: */ ! 248: ! 249: #if __STDC__ ! 250: ! 251: int closedir(register DIR *dirp) ! 252: ! 253: #else ! 254: ! 255: int closedir(dirp) ! 256: register DIR *dirp; /* stream from opendir() */ ! 257: ! 258: #endif ! 259: { ! 260: register int fd; ! 261: ! 262: if ( dirp == NULL || dirp->dd_buf == NULL ) { ! 263: errno = EFAULT; ! 264: return -1; /* invalid pointer */ ! 265: } ! 266: ! 267: fd = dirp->dd_fd; /* bug fix thanks to R. Salz */ ! 268: free( (pointer)dirp->dd_buf ); ! 269: free( (pointer)dirp ); ! 270: return close( fd ); ! 271: } ! 272: ! 273: ! 274: /* ! 275: readdir -- read next entry from a directory stream ! 276: ! 277: last edit: 25-Apr-1987 D A Gwyn ! 278: */ ! 279: ! 280: #if __STDC__ ! 281: ! 282: struct dirent *readdir(register DIR *dirp) ! 283: ! 284: #else ! 285: ! 286: struct dirent *readdir(dirp) ! 287: register DIR *dirp; /* stream from opendir() */ ! 288: ! 289: #endif ! 290: { ! 291: register struct dirent *dp; /* -> directory data */ ! 292: ! 293: if (dirp == NULL || dirp->dd_buf == NULL) { ! 294: errno = EFAULT; ! 295: return NULL; /* invalid pointer */ ! 296: } ! 297: do { ! 298: if (dirp->dd_loc >= dirp->dd_size) /* empty or obsolete */ ! 299: dirp->dd_loc = dirp->dd_size = 0; ! 300: ! 301: if (dirp->dd_size == 0 /* need to refill buffer */ ! 302: && (dirp->dd_size = ! 303: getdents(dirp->dd_fd, dirp->dd_buf, (unsigned) DIRBUF) ! 304: ) <= 0 ! 305: ) ! 306: return NULL; /* EOF or error */ ! 307: ! 308: dp = (struct dirent *) & dirp->dd_buf[dirp->dd_loc]; ! 309: dirp->dd_loc += dp->d_reclen; ! 310: } ! 311: while (dp->d_ino == 0L); /* don't rely on getdents() */ ! 312: ! 313: return dp; ! 314: } ! 315: ! 316: ! 317: /* ! 318: seekdir -- reposition a directory stream ! 319: ! 320: last edit: 24-May-1987 D A Gwyn ! 321: ! 322: An unsuccessful seekdir() will in general alter the current ! 323: directory position; beware. ! 324: ! 325: NOTE: 4.nBSD directory compaction makes seekdir() & telldir() ! 326: practically impossible to do right. Avoid using them! ! 327: */ ! 328: ! 329: #if __STDC__ ! 330: ! 331: void seekdir(register DIR *dirp, register OFFSET loc) ! 332: ! 333: #else ! 334: ! 335: void seekdir(dirp, loc) ! 336: register DIR *dirp; /* stream from opendir() */ ! 337: register OFFSET loc; /* position from telldir() */ ! 338: ! 339: #endif ! 340: { ! 341: register bool rewind; /* "start over when stymied" flag */ ! 342: ! 343: if (dirp == NULL || dirp->dd_buf == NULL) { ! 344: errno = EFAULT; ! 345: return; /* invalid pointer */ ! 346: } ! 347: /* ! 348: * A (struct dirent)'s d_off is an invented quantity on 4.nBSD ! 349: * NFS-supporting systems, so it is not safe to lseek() to it. ! 350: */ ! 351: ! 352: /* Monotonicity of d_off is heavily exploited in the following. */ ! 353: ! 354: /* ! 355: * This algorithm is tuned for modest directory sizes. For huge ! 356: * directories, it might be more efficient to read blocks until the first ! 357: * d_off is too large, then back up one block, or even to use binary ! 358: * search on the directory blocks. I doubt that the extra code for that ! 359: * would be worthwhile. ! 360: */ ! 361: ! 362: if (dirp->dd_loc >= dirp->dd_size /* invalid index */ ! 363: || ((struct dirent *) & dirp->dd_buf[dirp->dd_loc])->d_off > loc ! 364: /* too far along in buffer */ ! 365: ) ! 366: dirp->dd_loc = 0; /* reset to beginning of buffer */ ! 367: /* else save time by starting at current dirp->dd_loc */ ! 368: ! 369: for (rewind = true;;) { ! 370: register struct dirent *dp; ! 371: ! 372: /* See whether the matching entry is in the current buffer. */ ! 373: ! 374: if ((dirp->dd_loc < dirp->dd_size /* valid index */ ! 375: || readdir(dirp) != NULL /* next buffer read */ ! 376: && (dirp->dd_loc = 0, true) /* beginning of buffer set */ ! 377: ) ! 378: && (dp = (struct dirent *) & dirp->dd_buf[dirp->dd_loc])->d_off ! 379: <= loc /* match possible in this buffer */ ! 380: ) { ! 381: for ( /* dp initialized above */ ; ! 382: (char *) dp < &dirp->dd_buf[dirp->dd_size]; ! 383: dp = (struct dirent *) ((char *) dp + dp->d_reclen) ! 384: ) ! 385: if (dp->d_off == loc) { /* found it! */ ! 386: dirp->dd_loc = ! 387: (char *) dp - dirp->dd_buf; ! 388: return; ! 389: } ! 390: rewind = false; /* no point in backing up later */ ! 391: dirp->dd_loc = dirp->dd_size; /* set end of buffer */ ! 392: } else ! 393: /* whole buffer past matching entry */ if (!rewind) { /* no point in searching ! 394: * further */ ! 395: errno = EINVAL; ! 396: return; /* no entry at specified loc */ ! 397: } else { /* rewind directory and start over */ ! 398: rewind = false; /* but only once! */ ! 399: ! 400: dirp->dd_loc = dirp->dd_size = 0; ! 401: ! 402: if (lseek(dirp->dd_fd, (OFFSET) 0, SEEK_SET) ! 403: != 0 ! 404: ) ! 405: return; /* errno already set (EBADF) */ ! 406: ! 407: if (loc == 0) ! 408: return; /* save time */ ! 409: } ! 410: } ! 411: } ! 412: ! 413: ! 414: /* telldir - report directory stream position ! 415: * ! 416: * DESCRIPTION ! 417: * ! 418: * Returns the offset of the next directory entry in the ! 419: * directory associated with dirp. ! 420: * ! 421: * NOTE: 4.nBSD directory compaction makes seekdir() & telldir() ! 422: * practically impossible to do right. Avoid using them! ! 423: * ! 424: * PARAMETERS ! 425: * ! 426: * DIR *dirp - stream from opendir() ! 427: * ! 428: * RETURNS ! 429: * ! 430: * Return offset of next entry ! 431: */ ! 432: ! 433: ! 434: #if __STDC__ ! 435: ! 436: OFFSET telldir(DIR *dirp) ! 437: ! 438: #else ! 439: ! 440: OFFSET telldir(dirp) ! 441: DIR *dirp; /* stream from opendir() */ ! 442: ! 443: #endif ! 444: { ! 445: if (dirp == NULL || dirp->dd_buf == NULL) { ! 446: errno = EFAULT; ! 447: return -1; /* invalid pointer */ ! 448: } ! 449: if (dirp->dd_loc < dirp->dd_size) /* valid index */ ! 450: return ((struct dirent *) & dirp->dd_buf[dirp->dd_loc])->d_off; ! 451: else /* beginning of next directory block */ ! 452: return lseek(dirp->dd_fd, (OFFSET) 0, SEEK_CUR); ! 453: } ! 454: ! 455: ! 456: #ifdef UFS ! 457: ! 458: /* ! 459: The following routine is necessary to handle DIRSIZ-long entry names. ! 460: Thanks to Richard Todd for pointing this out. ! 461: */ ! 462: ! 463: ! 464: /* return # chars in embedded name */ ! 465: ! 466: #if __STDC__ ! 467: ! 468: static int NameLen(char *name) ! 469: ! 470: #else ! 471: ! 472: static int NameLen(name) ! 473: char *name; /* -> name embedded in struct direct */ ! 474: ! 475: #endif ! 476: { ! 477: register char *s; /* -> name[.] */ ! 478: register char *stop = &name[DIRSIZ]; /* -> past end of name field */ ! 479: ! 480: for (s = &name[1]; /* (empty names are impossible) */ ! 481: *s != '\0' /* not NUL terminator */ ! 482: && ++s < stop; /* < DIRSIZ characters scanned */ ! 483: ); ! 484: ! 485: return s - name; /* # valid characters in name */ ! 486: } ! 487: ! 488: #else /* BFS || NFS */ ! 489: ! 490: extern int strlen(); ! 491: ! 492: #define NameLen( name ) strlen( name ) /* names are always NUL-terminated */ ! 493: ! 494: #endif ! 495: ! 496: #ifdef UNK ! 497: static enum { ! 498: maybe, no, yes ! 499: } state = maybe; ! 500: ! 501: ! 502: /* sig_catch - used to catch signals ! 503: * ! 504: * DESCRIPTION ! 505: * ! 506: * Used to catch signals. ! 507: */ ! 508: ! 509: /*ARGSUSED*/ ! 510: ! 511: #if __STDC__ ! 512: ! 513: static void sig_catch(int sig) ! 514: ! 515: #else ! 516: ! 517: static void sig_catch(sig) ! 518: int sig; /* must be SIGSYS */ ! 519: ! 520: #endif ! 521: { ! 522: state = no; /* attempted _getdents() faulted */ ! 523: } ! 524: #endif ! 525: ! 526: ! 527: /* getdents - get directory entries ! 528: * ! 529: * DESCRIPTION ! 530: * ! 531: * Gets directory entries from the filesystem in an implemenation ! 532: * defined way. ! 533: * ! 534: * PARAMETERS ! 535: * ! 536: * int fildes - directory file descriptor ! 537: * char *buf - where to put the (struct dirent)s ! 538: * unsigned nbyte - size of buf[] ! 539: * ! 540: * RETURNS ! 541: * ! 542: * Returns number of bytes read; 0 on EOF, -1 on error ! 543: */ ! 544: ! 545: #if __STDC__ ! 546: ! 547: int getdents(int fildes, char *buf, unsigned nbyte) ! 548: ! 549: #else ! 550: ! 551: int getdents(fildes, buf, nbyte) ! 552: int fildes; /* directory file descriptor */ ! 553: char *buf; /* where to put the (struct dirent)s */ ! 554: unsigned nbyte; /* size of buf[] */ ! 555: ! 556: #endif ! 557: { ! 558: int serrno; /* entry errno */ ! 559: OFFSET offset; /* initial directory file offset */ ! 560: struct stat statb; /* fstat() info */ ! 561: union { ! 562: /* directory file block buffer */ ! 563: #ifdef UFS ! 564: char dblk[DIRBLKSIZ + 1]; ! 565: #else ! 566: char dblk[DIRBLKSIZ]; ! 567: #endif ! 568: struct direct dummy; /* just for alignment */ ! 569: } u; /* (avoids having to malloc()) */ ! 570: register struct direct *dp; /* -> u.dblk[.] */ ! 571: register struct dirent *bp; /* -> buf[.] */ ! 572: ! 573: #ifdef UNK ! 574: switch (state) { ! 575: SIG_T (*shdlr)(); /* entry SIGSYS handler */ ! 576: register int retval; /* return from _getdents() if any */ ! 577: ! 578: case yes: /* _getdents() is known to work */ ! 579: return _getdents(fildes, buf, nbyte); ! 580: ! 581: case maybe: /* first time only */ ! 582: shdlr = signal(SIGSYS, sig_catch); ! 583: retval = _getdents(fildes, buf, nbyte); /* try it */ ! 584: signal(SIGSYS, shdlr); ! 585: ! 586: if (state == maybe) { /* SIGSYS did not occur */ ! 587: state = yes; /* so _getdents() must have worked */ ! 588: return retval; ! 589: } ! 590: /* else fall through into emulation */ ! 591: ! 592: /* case no: /* fall through into emulation */ ! 593: } ! 594: #endif ! 595: ! 596: if (buf == NULL ! 597: #ifdef ATT_SPEC ! 598: || (unsigned long) buf % sizeof(long) != 0 /* ugh */ ! 599: #endif ! 600: ) { ! 601: errno = EFAULT; /* invalid pointer */ ! 602: return -1; ! 603: } ! 604: if (fstat(fildes, &statb) != 0) { ! 605: return -1; /* errno set by fstat() */ ! 606: } ! 607: ! 608: if (!S_ISDIR(statb.st_mode)) { ! 609: errno = ENOTDIR; /* not a directory */ ! 610: return -1; ! 611: } ! 612: if ((offset = lseek(fildes, (OFFSET) 0, SEEK_CUR)) < 0) { ! 613: return -1; /* errno set by lseek() */ ! 614: } ! 615: ! 616: #ifdef BFS /* no telling what remote hosts do */ ! 617: if ((unsigned long) offset % DIRBLKSIZ != 0) { ! 618: errno = ENOENT; /* file pointer probably misaligned */ ! 619: return -1; ! 620: } ! 621: #endif ! 622: ! 623: serrno = errno; /* save entry errno */ ! 624: ! 625: for (bp = (struct dirent *) buf; bp == (struct dirent *) buf;) { ! 626: ! 627: /* convert next directory block */ ! 628: int size; ! 629: ! 630: do { ! 631: size = GetBlock(fildes, u.dblk, DIRBLKSIZ); ! 632: } while (size == -1 && errno == EINTR); ! 633: ! 634: if (size <= 0) { ! 635: return size; /* EOF or error (EBADF) */ ! 636: } ! 637: ! 638: for (dp = (struct direct *) u.dblk; ! 639: (char *) dp < &u.dblk[size]; ! 640: dp = (struct direct *) ((char *) dp + RecLen(dp)) ! 641: ) { ! 642: #ifndef UFS ! 643: if (dp->d_reclen <= 0) { ! 644: errno = EIO; /* corrupted directory */ ! 645: return -1; ! 646: } ! 647: #endif ! 648: ! 649: if (dp->d_fileno != 0) { /* non-empty; copy to user buffer */ ! 650: register int reclen = ! 651: DIRENTSIZ(NameLen(dp->d_name)); ! 652: ! 653: if ((char *) bp + reclen > &buf[nbyte]) { ! 654: errno = EINVAL; ! 655: return -1; /* buf too small */ ! 656: } ! 657: bp->d_ino = dp->d_fileno; ! 658: bp->d_off = offset + ((char *) dp - u.dblk); ! 659: bp->d_reclen = reclen; ! 660: ! 661: { ! 662: #ifdef UFS ! 663: /* Is the following kludge ugly? You bet. */ ! 664: ! 665: register char save = dp->d_name[DIRSIZ]; ! 666: /* save original data */ ! 667: ! 668: dp->d_name[DIRSIZ] = '\0'; ! 669: /* ensure NUL termination */ ! 670: #endif ! 671: /* adds NUL padding */ ! 672: strncpy(bp->d_name, dp->d_name, reclen - DIRENTBASESIZ); ! 673: #ifdef UFS ! 674: dp->d_name[DIRSIZ] = save; ! 675: /* restore original data */ ! 676: #endif ! 677: } ! 678: ! 679: bp = (struct dirent *) ((char *) bp + reclen); ! 680: } ! 681: } ! 682: ! 683: #ifndef BFS /* 4.2BSD screwed up; fixed in 4.3BSD */ ! 684: if ((char *) dp > &u.dblk[size]) { ! 685: errno = EIO; /* corrupted directory */ ! 686: return -1; ! 687: } ! 688: #endif ! 689: } ! 690: ! 691: errno = serrno; /* restore entry errno */ ! 692: return (char *) bp - buf; /* return # bytes read */ ! 693: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.