/* * Change to dir specified by fd or p->fts_accpath without getting * tricked by someone changing the world out from underneath us. * Assumes p->fts_dev and p->fts_ino are filled in. */ static int internal_function fts_safe_changedir (FTSOBJ *sp, FTSENTRY *p, int fd, const char *path) { int ret, oerrno, newfd; struct stat64 sb; newfd = fd; if (ISSET(FTS_NOCHDIR)) return (0); if (fd < 0 && (newfd = __open(path, O_RDONLY, 0)) < 0) return (-1); if (__fxstat64(_STAT_VER, newfd, &sb)) { ret = -1; goto bail; } if (p->fts_dev != sb.st_dev || p->fts_ino != sb.st_ino) { __set_errno (ENOENT); /* disinformation */ ret = -1; goto bail; } ret = __fchdir(newfd); bail: oerrno = errno; if (fd < 0) (void)__close(newfd); __set_errno (oerrno); return (ret); }
int Fts_close(FTS * sp) { register FTSENT *freep, *p; int saved_errno; if (_fts_debug) fprintf(stderr, "--> Fts_close(%p)\n", sp); if (sp == NULL) return 0; /* * This still works if we haven't read anything -- the dummy structure * points to the root list, so we step through to the end of the root * list which has a valid parent pointer. */ if (sp->fts_cur) { for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) { freep = p; p = p->fts_link != NULL ? p->fts_link : p->fts_parent; free(freep); } free(p); } /* Free up child linked list, sort array, path buffer. */ if (sp->fts_child) fts_lfree(sp->fts_child); if (sp->fts_array) free(sp->fts_array); free(sp->fts_path); /* Return to original directory, save errno if necessary. */ if (!ISSET(FTS_NOCHDIR)) { saved_errno = __fchdir(sp->fts_rfd) ? errno : 0; (void)__close(sp->fts_rfd); /* Set errno and return. */ if (saved_errno != 0) { /* Free up the stream pointer. */ free(sp); __set_errno (saved_errno); return (-1); } } /* Free up the stream pointer. */ free(sp); return (0); }
int fchdir(int fd) { int e; funcptr __fchdir; DPRINT(("fchdir fd=%d \n", fd)); printf("fchdir not handled\n"); exit(-1); __fchdir = load_library_symbol("fchdir"); if (__fchdir == NULL) { errno = ENOENT; return -1; } e = __fchdir(fd); DPRINT(("fchdir fd=%d\n", fd, e)); return e; }
/* * Change to dir specified by fd or p->fts_accpath without getting * tricked by someone changing the world out from underneath us. * Assumes p->fts_dev and p->fts_ino are filled in. */ static int fts_safe_changedir(FTS * sp, FTSENT * p, int fd, const char * path) { int ret, oerrno, newfd; struct stat64 sb; newfd = fd; if (ISSET(FTS_NOCHDIR)) return (0); /* Permit open(2) on file:// prefixed URI paths. */ /* XXX todo: use Open(2), which is Chroot(2) path invariant. */ /* XXX todo: add Fts(3) options to disable the hackery? */ { const char * lpath = NULL; int ut = urlPath(path, &lpath); if (ut == URL_IS_PATH) path = lpath; } if (fd < 0 && (newfd = __open(path, O_RDONLY, 0)) < 0) return (-1); /*@-sysunrecog -unrecog @*/ if (__fxstat64(_STAT_VER, newfd, &sb)) { ret = -1; goto bail; } /*@=sysunrecog =unrecog @*/ if (p->fts_dev != sb.st_dev || p->fts_ino != sb.st_ino) { __set_errno (ENOENT); /* disinformation */ ret = -1; goto bail; } ret = __fchdir(newfd); bail: oerrno = errno; if (fd < 0) (void)__close(newfd); __set_errno (oerrno); return (ret); }
FTSENTRY * FTS_CHILDREN(FTSOBJ *sp, int instr) { FTSENTRY *p; int fd; if (instr != 0 && instr != FTS_NAMEONLY) { __set_errno (EINVAL); return (NULL); } /* Set current node pointer. */ p = sp->fts_cur; /* * Errno set to 0 so user can distinguish empty directory from * an error. */ __set_errno (0); /* Fatal errors stop here. */ if (ISSET(FTS_STOP)) return (NULL); /* Return logical hierarchy of user's arguments. */ if (p->fts_info == FTS_INIT) return (p->fts_link); /* * If not a directory being visited in pre-order, stop here. Could * allow FTS_DNR, assuming the user has fixed the problem, but the * same effect is available with FTS_AGAIN. */ if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */) return (NULL); /* Free up any previous child list. */ if (sp->fts_child != NULL) fts_lfree(sp->fts_child); if (instr == FTS_NAMEONLY) { SET(FTS_NAMEONLY); instr = BNAMES; } else instr = BCHILD; /* * If using chdir on a relative path and called BEFORE fts_read does * its chdir to the root of a traversal, we can lose -- we need to * chdir into the subdirectory, and we don't know where the current * directory is, so we can't get back so that the upcoming chdir by * fts_read will work. */ if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' || ISSET(FTS_NOCHDIR)) return (sp->fts_child = fts_build(sp, instr)); if ((fd = __open(".", O_RDONLY, 0)) < 0) return (NULL); sp->fts_child = fts_build(sp, instr); if (__fchdir(fd)) return (NULL); (void)__close(fd); return (sp->fts_child); }
ftw_startup (const char *dir, int is_nftw, void *func, int descriptors, int flags) { struct ftw_data data; struct STAT st; int result = 0; int save_err; int cwdfd = -1; char *cwd = NULL; char *cp; /* First make sure the parameters are reasonable. */ if (dir[0] == '\0') { __set_errno (ENOENT); return -1; } data.maxdir = descriptors < 1 ? 1 : descriptors; data.actdir = 0; data.dirstreams = (struct dir_data **) alloca (data.maxdir * sizeof (struct dir_data *)); memset (data.dirstreams, '\0', data.maxdir * sizeof (struct dir_data *)); /* PATH_MAX is always defined when we get here. */ data.dirbufsize = MAX (2 * strlen (dir), PATH_MAX); data.dirbuf = (char *) malloc (data.dirbufsize); if (data.dirbuf == NULL) return -1; cp = __stpcpy (data.dirbuf, dir); /* Strip trailing slashes. */ while (cp > data.dirbuf + 1 && cp[-1] == '/') --cp; *cp = '\0'; data.ftw.level = 0; /* Find basename. */ while (cp > data.dirbuf && cp[-1] != '/') --cp; data.ftw.base = cp - data.dirbuf; data.flags = flags; /* This assignment might seem to be strange but it is what we want. The trick is that the first three arguments to the `ftw' and `nftw' callback functions are equal. Therefore we can call in every case the callback using the format of the `nftw' version and get the correct result since the stack layout for a function call in C allows this. */ data.func = (NFTW_FUNC_T) func; /* Since we internally use the complete set of FTW_* values we need to reduce the value range before calling a `ftw' callback. */ data.cvt_arr = is_nftw ? nftw_arr : ftw_arr; /* No object known so far. */ data.known_objects = NULL; /* Now go to the directory containing the initial file/directory. */ if (flags & FTW_CHDIR) { /* We have to be able to go back to the current working directory. The best way to do this is to use a file descriptor. */ cwdfd = __open (".", O_RDONLY | O_DIRECTORY); if (cwdfd == -1) { /* Try getting the directory name. This can be needed if the current directory is executable but not readable. */ if (errno == EACCES) /* GNU extension ahead. */ cwd = __getcwd (NULL, 0); if (cwd == NULL) goto out_fail; } else if (data.maxdir > 1) /* Account for the file descriptor we use here. */ --data.maxdir; if (data.ftw.base > 0) { /* Change to the directory the file is in. In data.dirbuf we have a writable copy of the file name. Just NUL terminate it for now and change the directory. */ if (data.ftw.base == 1) /* I.e., the file is in the root directory. */ result = __chdir ("/"); else { char ch = data.dirbuf[data.ftw.base - 1]; data.dirbuf[data.ftw.base - 1] = '\0'; result = __chdir (data.dirbuf); data.dirbuf[data.ftw.base - 1] = ch; } } } /* Get stat info for start directory. */ if (result == 0) { const char *name; if (data.flags & FTW_CHDIR) { name = data.dirbuf + data.ftw.base; if (name[0] == '\0') name = "."; } else name = data.dirbuf; if (((flags & FTW_PHYS) ? LXSTAT (_STAT_VER, name, &st) : XSTAT (_STAT_VER, name, &st)) < 0) { if (!(flags & FTW_PHYS) && errno == ENOENT && LXSTAT (_STAT_VER, name, &st) == 0 && S_ISLNK (st.st_mode)) result = (*data.func) (data.dirbuf, &st, data.cvt_arr[FTW_SLN], &data.ftw); else /* No need to call the callback since we cannot say anything about the object. */ result = -1; } else { if (S_ISDIR (st.st_mode)) { /* Remember the device of the initial directory in case FTW_MOUNT is given. */ data.dev = st.st_dev; /* We know this directory now. */ if (!(flags & FTW_PHYS)) result = add_object (&data, &st); if (result == 0) result = ftw_dir (&data, &st, NULL); } else { int flag = S_ISLNK (st.st_mode) ? FTW_SL : FTW_F; result = (*data.func) (data.dirbuf, &st, data.cvt_arr[flag], &data.ftw); } } if ((flags & FTW_ACTIONRETVAL) && (result == FTW_SKIP_SUBTREE || result == FTW_SKIP_SIBLINGS)) result = 0; } /* Return to the start directory (if necessary). */ if (cwdfd != -1) { int save_err = errno; __fchdir (cwdfd); __close_nocancel_nostatus (cwdfd); __set_errno (save_err); } else if (cwd != NULL) { int save_err = errno; __chdir (cwd); free (cwd); __set_errno (save_err); } /* Free all memory. */ out_fail: save_err = errno; __tdestroy (data.known_objects, free); free (data.dirbuf); __set_errno (save_err); return result; }
ftw_dir (struct ftw_data *data, struct STAT *st, struct dir_data *old_dir) { struct dir_data dir; struct dirent64 *d; int previous_base = data->ftw.base; int result; char *startp; /* Open the stream for this directory. This might require that another stream has to be closed. */ result = open_dir_stream (old_dir == NULL ? NULL : &old_dir->streamfd, data, &dir); if (result != 0) { if (errno == EACCES) /* We cannot read the directory. Signal this with a special flag. */ result = (*data->func) (data->dirbuf, st, FTW_DNR, &data->ftw); return result; } /* First, report the directory (if not depth-first). */ if (!(data->flags & FTW_DEPTH)) { result = (*data->func) (data->dirbuf, st, FTW_D, &data->ftw); if (result != 0) { int save_err; fail: save_err = errno; __closedir (dir.stream); dir.streamfd = -1; __set_errno (save_err); if (data->actdir-- == 0) data->actdir = data->maxdir - 1; data->dirstreams[data->actdir] = NULL; return result; } } /* If necessary, change to this directory. */ if (data->flags & FTW_CHDIR) { if (__fchdir (__dirfd (dir.stream)) < 0) { result = -1; goto fail; } } /* Next, update the `struct FTW' information. */ ++data->ftw.level; startp = __rawmemchr (data->dirbuf, '\0'); /* There always must be a directory name. */ assert (startp != data->dirbuf); if (startp[-1] != '/') *startp++ = '/'; data->ftw.base = startp - data->dirbuf; while (dir.stream != NULL && (d = __readdir64 (dir.stream)) != NULL) { int d_type = DT_UNKNOWN; #ifdef _DIRENT_HAVE_D_TYPE d_type = d->d_type; #endif result = process_entry (data, &dir, d->d_name, NAMLEN (d), d_type); if (result != 0) break; } if (dir.stream != NULL) { /* The stream is still open. I.e., we did not need more descriptors. Simply close the stream now. */ int save_err = errno; assert (dir.content == NULL); __closedir (dir.stream); dir.streamfd = -1; __set_errno (save_err); if (data->actdir-- == 0) data->actdir = data->maxdir - 1; data->dirstreams[data->actdir] = NULL; } else { int save_err; char *runp = dir.content; while (result == 0 && *runp != '\0') { char *endp = strchr (runp, '\0'); // XXX Should store the d_type values as well?! result = process_entry (data, &dir, runp, endp - runp, DT_UNKNOWN); runp = endp + 1; } save_err = errno; free (dir.content); __set_errno (save_err); } if ((data->flags & FTW_ACTIONRETVAL) && result == FTW_SKIP_SIBLINGS) result = 0; /* Prepare the return, revert the `struct FTW' information. */ data->dirbuf[data->ftw.base - 1] = '\0'; --data->ftw.level; data->ftw.base = previous_base; /* Finally, if we process depth-first report the directory. */ if (result == 0 && (data->flags & FTW_DEPTH)) result = (*data->func) (data->dirbuf, st, FTW_DP, &data->ftw); if (old_dir && (data->flags & FTW_CHDIR) && (result == 0 || ((data->flags & FTW_ACTIONRETVAL) && (result != -1 && result != FTW_STOP)))) { /* Change back to the parent directory. */ int done = 0; if (old_dir->stream != NULL) if (__fchdir (__dirfd (old_dir->stream)) == 0) done = 1; if (!done) { if (data->ftw.base == 1) { if (__chdir ("/") < 0) result = -1; } else if (__chdir ("..") < 0) result = -1; } } return result; }
int fchdir(int filedes) { _gfs_hook_debug_v(fputs("Hooking fchdir\n", stderr)); return (__fchdir(filedes)); }