/* opendir -- open a directory stream last edit: 16-Jun-1987 D A Gwyn */ #include #include #include #include "paxdir.h" #ifdef BSD_SYSV /* -- definitions for 4.2,4.3BSD directories last edit: 25-Apr-1987 D A Gwyn A directory consists of some number of blocks of DIRBLKSIZ bytes each, where DIRBLKSIZ is chosen such that it can be transferred to disk in a single atomic operation (e.g., 512 bytes on most machines). Each DIRBLKSIZ-byte block contains some number of directory entry structures, which are of variable length. Each directory entry has the beginning of a (struct direct) at the front of it, containing its filesystem-unique ident number, the length of the entry, and the length of the name contained in the entry. These are followed by the NUL- terminated name padded to a (long) boundary with 0 bytes. The maximum length of a name in a directory is MAXNAMELEN. The macro DIRSIZ(dp) gives the amount of space required to represent a directory entry. Free space in a directory is represented by entries that have dp->d_reclen > DIRSIZ(dp). All DIRBLKSIZ bytes in a directory block are claimed by the directory entries; this usually results in the last entry in a directory having a large dp->d_reclen. When entries are deleted from a directory, the space is returned to the previous entry in the same directory block by increasing its dp->d_reclen. If the first entry of a directory block is free, then its dp->d_fileno is set to 0; entries other than the first in a directory do not normally have dp->d_fileno set to 0. prerequisite: */ #if defined(accel) || defined(sun) || defined(vax) #define DIRBLKSIZ 512 /* size of directory block */ #else #ifdef alliant #define DIRBLKSIZ 4096 /* size of directory block */ #else #ifdef gould #define DIRBLKSIZ 1024 /* size of directory block */ #else #ifdef ns32000 /* Dynix System V */ #define DIRBLKSIZ 2600 /* size of directory block */ #else /* be conservative; multiple blocks are okay * but fractions are not */ #define DIRBLKSIZ 4096 /* size of directory block */ #endif #endif #endif #endif #define MAXNAMELEN 255 /* maximum filename length */ /* NOTE: not MAXNAMLEN, which has been preempted by SVR3 */ struct direct { /* data from read()/_getdirentries() */ unsigned long d_fileno; /* unique ident of entry */ unsigned short d_reclen; /* length of this record */ unsigned short d_namlen; /* length of string in d_name */ char d_name[MAXNAMELEN + 1]; /* NUL-terminated filename */ }; /* The DIRSIZ macro gives the minimum record length which will hold the directory entry. This requires the amount of space in a (struct direct) without the d_name field, plus enough space for the name with a terminating NUL character, rounded up to a (long) boundary. (Note that Berkeley didn't properly compensate for struct padding, but we nevertheless have to use the same size as the actual system.) */ #define DIRSIZ( dp ) ((sizeof(struct direct) - (MAXNAMELEN+1) \ + sizeof(long) + (dp)->d_namlen) \ / sizeof(long) * sizeof(long)) #else #include #ifdef SYSV3 #undef MAXNAMLEN /* avoid conflict with SVR3 */ #endif /* Good thing we don't need to use the DIRSIZ() macro! */ #ifdef d_ino /* 4.3BSD/NFS using d_fileno */ #undef d_ino /* (not absolutely necessary) */ #else #define d_fileno d_ino /* (struct direct) member */ #endif #endif #ifdef UNK #ifndef UFS #include "***** ERROR ***** UNK applies only to UFS" /* One could do something similar for getdirentries(), but I didn't bother. */ #endif #include #endif #if defined(UFS) + defined(BFS) + defined(NFS) != 1 /* sanity check */ #include "***** ERROR ***** exactly one of UFS, BFS, or NFS must be defined" #endif #ifdef UFS #define RecLen( dp ) (sizeof(struct direct)) /* fixed-length entries */ #else /* BFS || NFS */ #define RecLen( dp ) ((dp)->d_reclen) /* variable-length entries */ #endif #ifdef NFS #ifdef BSD_SYSV #define getdirentries _getdirentries /* package hides this system call */ #endif extern int getdirentries(); static long dummy; /* getdirentries() needs basep */ #define GetBlock( fd, buf, n ) getdirentries( fd, buf, (unsigned)n, &dummy ) #else /* UFS || BFS */ #ifdef BSD_SYSV #define read _read /* avoid emulation overhead */ #endif extern int read(); #define GetBlock( fd, buf, n ) read( fd, buf, (unsigned)n ) #endif #ifdef UNK extern int _getdents(); /* actual system call */ #endif extern char *strncpy(); extern int fstat(); extern OFFSET lseek(); extern int errno; #ifndef DIRBLKSIZ #define DIRBLKSIZ 4096 /* directory file read buffer size */ #endif #ifndef NULL #define NULL 0 #endif #ifndef SEEK_CUR #define SEEK_CUR 1 #endif #ifndef S_ISDIR /* macro to test for directory file */ #define S_ISDIR( mode ) (((mode) & S_IFMT) == S_IFDIR) #endif #ifndef SEEK_CUR #define SEEK_CUR 1 #endif #ifdef BSD_SYSV #define open _open /* avoid emulation overhead */ #endif extern int getdents(); /* SVR3 system call, or emulation */ typedef char *pointer; /* (void *) if you have it */ extern void free(); extern pointer malloc(); extern int open(), close(), fstat(); extern int errno; extern OFFSET lseek(); #ifndef SEEK_SET #define SEEK_SET 0 #endif typedef int bool; /* Boolean data type */ #define false 0 #define true 1 #ifndef NULL #define NULL 0 #endif #ifndef O_RDONLY #define O_RDONLY 0 #endif #ifndef S_ISDIR /* macro to test for directory file */ #define S_ISDIR( mode ) (((mode) & S_IFMT) == S_IFDIR) #endif #ifdef __STDC__ DIR *opendir(char *dirname) #else DIR *opendir(dirname) char *dirname; /* name of directory */ #endif { register DIR *dirp; /* -> malloc'ed storage */ register int fd; /* file descriptor for read */ struct stat sbuf; /* result of fstat() */ if ((fd = open(dirname, O_RDONLY)) < 0) return ((DIR *)NULL); /* errno set by open() */ if (fstat(fd, &sbuf) != 0 || !S_ISDIR(sbuf.st_mode)) { close(fd); errno = ENOTDIR; return ((DIR *)NULL); /* not a directory */ } if ((dirp = (DIR *) malloc(sizeof(DIR))) == (DIR *)NULL || (dirp->dd_buf = (char *) malloc((unsigned) DIRBUF)) == (char *)NULL ) { register int serrno = errno; /* errno set to ENOMEM by sbrk() */ if (dirp != (DIR *)NULL) free((pointer) dirp); close(fd); errno = serrno; return ((DIR *)NULL); /* not enough memory */ } dirp->dd_fd = fd; dirp->dd_loc = dirp->dd_size = 0; /* refill needed */ return dirp; } /* * closedir -- close a directory stream * * last edit: 11-Nov-1988 D A Gwyn */ #ifdef __STDC__ int closedir(register DIR *dirp) #else int closedir(dirp) register DIR *dirp; /* stream from opendir() */ #endif { register int fd; if ( dirp == (DIR *)NULL || dirp->dd_buf == (char *)NULL ) { errno = EFAULT; return -1; /* invalid pointer */ } fd = dirp->dd_fd; /* bug fix thanks to R. Salz */ free( (pointer)dirp->dd_buf ); free( (pointer)dirp ); return close( fd ); } /* readdir -- read next entry from a directory stream last edit: 25-Apr-1987 D A Gwyn */ #ifdef __STDC__ struct dirent *readdir(register DIR *dirp) #else struct dirent *readdir(dirp) register DIR *dirp; /* stream from opendir() */ #endif { register struct dirent *dp; /* -> directory data */ if (dirp == (DIR *)NULL || dirp->dd_buf == (char *)NULL) { errno = EFAULT; return (struct dirent *)NULL; /* invalid pointer */ } do { if (dirp->dd_loc >= dirp->dd_size) /* empty or obsolete */ dirp->dd_loc = dirp->dd_size = 0; if (dirp->dd_size == 0 /* need to refill buffer */ && (dirp->dd_size = getdents(dirp->dd_fd, dirp->dd_buf, (unsigned) DIRBUF) ) <= 0 ) return ((struct dirent *)NULL); /* EOF or error */ dp = (struct dirent *) & dirp->dd_buf[dirp->dd_loc]; dirp->dd_loc += dp->d_reclen; } while (dp->d_ino == 0L); /* don't rely on getdents() */ return dp; } /* seekdir -- reposition a directory stream last edit: 24-May-1987 D A Gwyn An unsuccessful seekdir() will in general alter the current directory position; beware. NOTE: 4.nBSD directory compaction makes seekdir() & telldir() practically impossible to do right. Avoid using them! */ #ifdef __STDC__ void seekdir(register DIR *dirp, register OFFSET loc) #else void seekdir(dirp, loc) register DIR *dirp; /* stream from opendir() */ register OFFSET loc; /* position from telldir() */ #endif { register bool rewind; /* "start over when stymied" flag */ if (dirp == (DIR *)NULL || dirp->dd_buf == (char *)NULL) { errno = EFAULT; return; /* invalid pointer */ } /* * A (struct dirent)'s d_off is an invented quantity on 4.nBSD * NFS-supporting systems, so it is not safe to lseek() to it. */ /* Monotonicity of d_off is heavily exploited in the following. */ /* * This algorithm is tuned for modest directory sizes. For huge * directories, it might be more efficient to read blocks until the first * d_off is too large, then back up one block, or even to use binary * search on the directory blocks. I doubt that the extra code for that * would be worthwhile. */ if (dirp->dd_loc >= dirp->dd_size /* invalid index */ || ((struct dirent *) & dirp->dd_buf[dirp->dd_loc])->d_off > loc /* too far along in buffer */ ) dirp->dd_loc = 0; /* reset to beginning of buffer */ /* else save time by starting at current dirp->dd_loc */ for (rewind = true;;) { register struct dirent *dp; /* See whether the matching entry is in the current buffer. */ if ((dirp->dd_loc < dirp->dd_size /* valid index */ || readdir(dirp) != (struct dirent *)NULL /* next buffer read */ && (dirp->dd_loc = 0, true) /* beginning of buffer set */ ) && (dp = (struct dirent *) & dirp->dd_buf[dirp->dd_loc])->d_off <= loc /* match possible in this buffer */ ) { for ( /* dp initialized above */ ; (char *) dp < &dirp->dd_buf[dirp->dd_size]; dp = (struct dirent *) ((char *) dp + dp->d_reclen) ) if (dp->d_off == loc) { /* found it! */ dirp->dd_loc = (char *) dp - dirp->dd_buf; return; } rewind = false; /* no point in backing up later */ dirp->dd_loc = dirp->dd_size; /* set end of buffer */ } else /* whole buffer past matching entry */ if (!rewind) { /* no point in searching * further */ errno = EINVAL; return; /* no entry at specified loc */ } else { /* rewind directory and start over */ rewind = false; /* but only once! */ dirp->dd_loc = dirp->dd_size = 0; if (lseek(dirp->dd_fd, (OFFSET) 0, SEEK_SET) != 0 ) return; /* errno already set (EBADF) */ if (loc == 0) return; /* save time */ } } } /* telldir - report directory stream position * * DESCRIPTION * * Returns the offset of the next directory entry in the * directory associated with dirp. * * NOTE: 4.nBSD directory compaction makes seekdir() & telldir() * practically impossible to do right. Avoid using them! * * PARAMETERS * * DIR *dirp - stream from opendir() * * RETURNS * * Return offset of next entry */ #ifdef __STDC__ OFFSET telldir(DIR *dirp) #else OFFSET telldir(dirp) DIR *dirp; /* stream from opendir() */ #endif { if (dirp == (DIR *)NULL || dirp->dd_buf == (char *)NULL) { errno = EFAULT; return -1; /* invalid pointer */ } if (dirp->dd_loc < dirp->dd_size) /* valid index */ return ((struct dirent *) & dirp->dd_buf[dirp->dd_loc])->d_off; else /* beginning of next directory block */ return lseek(dirp->dd_fd, (OFFSET) 0, SEEK_CUR); } #ifdef UFS /* The following routine is necessary to handle DIRSIZ-long entry names. Thanks to Richard Todd for pointing this out. */ /* return # chars in embedded name */ #ifdef __STDC__ static int NameLen(char *name) #else static int NameLen(name) char *name; /* -> name embedded in struct direct */ #endif { register char *s; /* -> name[.] */ register char *stop = &name[DIRSIZ]; /* -> past end of name field */ for (s = &name[1]; /* (empty names are impossible) */ *s != '\0' /* not NUL terminator */ && ++s < stop; /* < DIRSIZ characters scanned */ ); return s - name; /* # valid characters in name */ } #else /* BFS || NFS */ extern int strlen(); #define NameLen( name ) strlen( name ) /* names are always NUL-terminated */ #endif #ifdef UNK static enum { maybe, no, yes } state = maybe; /* sig_catch - used to catch signals * * DESCRIPTION * * Used to catch signals. */ /*ARGSUSED*/ #ifdef __STDC__ static void sig_catch(int sig) #else static void sig_catch(sig) int sig; /* must be SIGSYS */ #endif { state = no; /* attempted _getdents() faulted */ } #endif /* getdents - get directory entries * * DESCRIPTION * * Gets directory entries from the filesystem in an implemenation * defined way. * * PARAMETERS * * int fildes - directory file descriptor * char *buf - where to put the (struct dirent)s * unsigned nbyte - size of buf[] * * RETURNS * * Returns number of bytes read; 0 on EOF, -1 on error */ #ifdef __STDC__ int getdents(int fildes, char *buf, unsigned nbyte) #else int getdents(fildes, buf, nbyte) int fildes; /* directory file descriptor */ char *buf; /* where to put the (struct dirent)s */ unsigned nbyte; /* size of buf[] */ #endif { int serrno; /* entry errno */ OFFSET offset; /* initial directory file offset */ struct stat statb; /* fstat() info */ union { /* directory file block buffer */ #ifdef UFS char dblk[DIRBLKSIZ + 1]; #else char dblk[DIRBLKSIZ]; #endif struct direct dummy; /* just for alignment */ } u; /* (avoids having to malloc()) */ register struct direct *dp; /* -> u.dblk[.] */ register struct dirent *bp; /* -> buf[.] */ #ifdef UNK switch (state) { SIG_T (*shdlr)(); /* entry SIGSYS handler */ register int retval; /* return from _getdents() if any */ case yes: /* _getdents() is known to work */ return _getdents(fildes, buf, nbyte); case maybe: /* first time only */ shdlr = signal(SIGSYS, sig_catch); retval = _getdents(fildes, buf, nbyte); /* try it */ signal(SIGSYS, shdlr); if (state == maybe) { /* SIGSYS did not occur */ state = yes; /* so _getdents() must have worked */ return retval; } /* else fall through into emulation */ /* case no: /* fall through into emulation */ } #endif if (buf == (char *)NULL #ifdef ATT_SPEC || (unsigned long) buf % sizeof(long) != 0 /* ugh */ #endif ) { errno = EFAULT; /* invalid pointer */ return -1; } if (fstat(fildes, &statb) != 0) { return -1; /* errno set by fstat() */ } if (!S_ISDIR(statb.st_mode)) { errno = ENOTDIR; /* not a directory */ return -1; } if ((offset = lseek(fildes, (OFFSET) 0, SEEK_CUR)) < 0) { return -1; /* errno set by lseek() */ } #ifdef BFS /* no telling what remote hosts do */ if ((unsigned long) offset % DIRBLKSIZ != 0) { errno = ENOENT; /* file pointer probably misaligned */ return -1; } #endif serrno = errno; /* save entry errno */ for (bp = (struct dirent *) buf; bp == (struct dirent *) buf;) { /* convert next directory block */ int size; do { size = GetBlock(fildes, u.dblk, DIRBLKSIZ); } while (size == -1 && errno == EINTR); if (size <= 0) { return size; /* EOF or error (EBADF) */ } for (dp = (struct direct *) u.dblk; (char *) dp < &u.dblk[size]; dp = (struct direct *) ((char *) dp + RecLen(dp)) ) { #ifndef UFS if (dp->d_reclen <= 0) { errno = EIO; /* corrupted directory */ return -1; } #endif if (dp->d_fileno != 0) { /* non-empty; copy to user buffer */ register int reclen = DIRENTSIZ(NameLen(dp->d_name)); if ((char *) bp + reclen > &buf[nbyte]) { errno = EINVAL; return -1; /* buf too small */ } bp->d_ino = dp->d_fileno; bp->d_off = offset + ((char *) dp - u.dblk); bp->d_reclen = reclen; { #ifdef UFS /* Is the following kludge ugly? You bet. */ register char save = dp->d_name[DIRSIZ]; /* save original data */ dp->d_name[DIRSIZ] = '\0'; /* ensure NUL termination */ #endif /* adds NUL padding */ strncpy(bp->d_name, dp->d_name, reclen - DIRENTBASESIZ); #ifdef UFS dp->d_name[DIRSIZ] = save; /* restore original data */ #endif } bp = (struct dirent *) ((char *) bp + reclen); } } #ifndef BFS /* 4.2BSD screwed up; fixed in 4.3BSD */ if ((char *) dp > &u.dblk[size]) { errno = EIO; /* corrupted directory */ return -1; } #endif } errno = serrno; /* restore entry errno */ return (char *) bp - buf; /* return # bytes read */ }