55static FTSENT *fts_alloc(FTS *, char *, size_t);
56static FTSENT *fts_build(FTS *, int);
57static void fts_lfree(FTSENT *);
58static void fts_load(FTS *, FTSENT *);
59static size_t fts_maxarglen(char * const *);
60static void fts_padjust(FTS *, FTSENT *);
61static int fts_palloc(FTS *, size_t);
62static FTSENT *fts_sort(FTS *, FTSENT *, size_t);
63static int fts_stat(FTS *, FTSENT *, int);
64static int fts_safe_changedir(FTS *, FTSENT *, int, char *);
65static int fts_ufslinks(FTS *, const FTSENT *);
66
67#define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
68
69#define CLR(opt) (sp->fts_options &= ~(opt))
70#define ISSET(opt) (sp->fts_options & (opt))
71#define SET(opt) (sp->fts_options |= (opt))
72
73#define FCHDIR(sp, fd) (!ISSET(FTS_NOCHDIR) && fchdir(fd))
74
75/* fts_build flags */
76#define BCHILD 1 /* fts_children */
77#define BNAMES 2 /* fts_children, names only */
78#define BREAD 3 /* fts_read */
79
80/*
81 * Internal representation of an FTS, including extra implementation
82 * details. The FTS returned from fts_open points to this structure's
83 * ftsp_fts member (and can be cast to an _fts_private as required)
84 */
85struct _fts_private {
86 FTS ftsp_fts;
87 struct statfs ftsp_statfs;
88 dev_t ftsp_dev;
89 int ftsp_linksreliable;
90};
91
92/*
93 * The "FTS_NOSTAT" option can avoid a lot of calls to stat(2) if it
94 * knows that a directory could not possibly have subdirectories. This
95 * is decided by looking at the link count: a subdirectory would
96 * increment its parent's link count by virtue of its own ".." entry.
97 * This assumption only holds for UFS-like filesystems that implement
98 * links and directories this way, so we must punt for others.
99 */
100
101static const char *ufslike_filesystems[] = {
102 "ufs",
103 "zfs",
104 "nfs",
105 "nfs4",
106 "ext2fs",
107 0
108};
109
110FTS *
111fts_open(argv, options, compar)
112 char * const *argv;
113 int options;
114 int (*compar)(const FTSENT * const *, const FTSENT * const *);
115{
116 struct _fts_private *priv;
117 FTS *sp;
118 FTSENT *p, *root;
119 FTSENT *parent, *tmp;
120 size_t len, nitems;
121
122 /* Options check. */
123 if (options & ~FTS_OPTIONMASK) {
124 errno = EINVAL;
125 return (NULL);
126 }
127
128 /* fts_open() requires at least one path */
129 if (*argv == NULL) {
130 errno = EINVAL;
131 return (NULL);
132 }
133
134 /* Allocate/initialize the stream. */
135 if ((priv = malloc(sizeof(*priv))) == NULL)
136 return (NULL);
137 memset(priv, 0, sizeof(*priv));
138 sp = &priv->ftsp_fts;
139 sp->fts_compar = compar;
140 sp->fts_options = options;
141
142 /* Shush, GCC. */
143 tmp = NULL;
144
145 /* Logical walks turn on NOCHDIR; symbolic links are too hard. */
146 if (ISSET(FTS_LOGICAL))
147 SET(FTS_NOCHDIR);
148
149 /*
150 * Start out with 1K of path space, and enough, in any case,
151 * to hold the user's paths.
152 */
153 if (fts_palloc(sp, MAX(fts_maxarglen(argv), MAXPATHLEN)))
154 goto mem1;
155
156 /* Allocate/initialize root's parent. */
157 if ((parent = fts_alloc(sp, "", 0)) == NULL)
158 goto mem2;
159 parent->fts_level = FTS_ROOTPARENTLEVEL;
160
161 /* Allocate/initialize root(s). */
162 for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
163 /* Don't allow zero-length paths. */
164 if ((len = strlen(*argv)) == 0) {
165 errno = ENOENT;
166 goto mem3;
167 }
168
169 p = fts_alloc(sp, *argv, len);
170 p->fts_level = FTS_ROOTLEVEL;
171 p->fts_parent = parent;
172 p->fts_accpath = p->fts_name;
173 p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW));
174
175 /* Command-line "." and ".." are real directories. */
176 if (p->fts_info == FTS_DOT)
177 p->fts_info = FTS_D;
178
179 /*
180 * If comparison routine supplied, traverse in sorted
181 * order; otherwise traverse in the order specified.
182 */
183 if (compar) {
184 p->fts_link = root;
185 root = p;
186 } else {
187 p->fts_link = NULL;
188 if (root == NULL)
189 tmp = root = p;
190 else {
191 tmp->fts_link = p;
192 tmp = p;
193 }
194 }
195 }
196 if (compar && nitems > 1)
197 root = fts_sort(sp, root, nitems);
198
199 /*
200 * Allocate a dummy pointer and make fts_read think that we've just
201 * finished the node before the root(s); set p->fts_info to FTS_INIT
202 * so that everything about the "current" node is ignored.
203 */
204 if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
205 goto mem3;
206 sp->fts_cur->fts_link = root;
207 sp->fts_cur->fts_info = FTS_INIT;
208
209 /*
210 * If using chdir(2), grab a file descriptor pointing to dot to ensure
211 * that we can get back here; this could be avoided for some paths,
212 * but almost certainly not worth the effort. Slashes, symbolic links,
213 * and ".." are all fairly nasty problems. Note, if we can't get the
214 * descriptor we run anyway, just more slowly.
215 */
216 if (!ISSET(FTS_NOCHDIR) && (sp->fts_rfd = _open(".", O_RDONLY, 0)) < 0)
217 SET(FTS_NOCHDIR);
218
219 return (sp);
220
221mem3: fts_lfree(root);
222 free(parent);
223mem2: free(sp->fts_path);
224mem1: free(sp);
225 return (NULL);
226}
227
228static void
229fts_load(FTS *sp, FTSENT *p)
230{
231 size_t len;
232 char *cp;
233
234 /*
235 * Load the stream structure for the next traversal. Since we don't
236 * actually enter the directory until after the preorder visit, set
237 * the fts_accpath field specially so the chdir gets done to the right
238 * place and the user can access the first node. From fts_open it's
239 * known that the path will fit.
240 */
241 len = p->fts_pathlen = p->fts_namelen;
242 memmove(sp->fts_path, p->fts_name, len + 1);
243 if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
244 len = strlen(++cp);
245 memmove(p->fts_name, cp, len + 1);
246 p->fts_namelen = len;
247 }
248 p->fts_accpath = p->fts_path = sp->fts_path;
249 sp->fts_dev = p->fts_dev;
250}
251
252int
253fts_close(FTS *sp)
254{
255 FTSENT *freep, *p;
256 int saved_errno;
257
258 /*
259 * This still works if we haven't read anything -- the dummy structure
260 * points to the root list, so we step through to the end of the root
261 * list which has a valid parent pointer.
262 */
263 if (sp->fts_cur) {
264 for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
265 freep = p;
266 p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
267 free(freep);
268 }
269 free(p);
270 }
271
272 /* Free up child linked list, sort array, path buffer. */
273 if (sp->fts_child)
274 fts_lfree(sp->fts_child);
275 if (sp->fts_array)
276 free(sp->fts_array);
277 free(sp->fts_path);
278
279 /* Return to original directory, save errno if necessary. */
280 if (!ISSET(FTS_NOCHDIR)) {
281 saved_errno = fchdir(sp->fts_rfd) ? errno : 0;
282 (void)_close(sp->fts_rfd);
283
284 /* Set errno and return. */
285 if (saved_errno != 0) {
286 /* Free up the stream pointer. */
287 free(sp);
288 errno = saved_errno;
289 return (-1);
290 }
291 }
292
293 /* Free up the stream pointer. */
294 free(sp);
295 return (0);
296}
297
298/*
299 * Special case of "/" at the end of the path so that slashes aren't
300 * appended which would cause paths to be written as "....//foo".
301 */
302#define NAPPEND(p) \
303 (p->fts_path[p->fts_pathlen - 1] == '/' \
304 ? p->fts_pathlen - 1 : p->fts_pathlen)
305
306FTSENT *
307fts_read(FTS *sp)
308{
309 FTSENT *p, *tmp;
310 int instr;
311 char *t;
312 int saved_errno;
313
314 /* If finished or unrecoverable error, return NULL. */
315 if (sp->fts_cur == NULL || ISSET(FTS_STOP))
316 return (NULL);
317
318 /* Set current node pointer. */
319 p = sp->fts_cur;
320
321 /* Save and zero out user instructions. */
322 instr = p->fts_instr;
323 p->fts_instr = FTS_NOINSTR;
324
325 /* Any type of file may be re-visited; re-stat and re-turn. */
326 if (instr == FTS_AGAIN) {
327 p->fts_info = fts_stat(sp, p, 0);
328 return (p);
329 }
330
331 /*
332 * Following a symlink -- SLNONE test allows application to see
333 * SLNONE and recover. If indirecting through a symlink, have
334 * keep a pointer to current location. If unable to get that
335 * pointer, follow fails.
336 */
337 if (instr == FTS_FOLLOW &&
338 (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
339 p->fts_info = fts_stat(sp, p, 1);
340 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
341 if ((p->fts_symfd = _open(".", O_RDONLY, 0)) < 0) {
342 p->fts_errno = errno;
343 p->fts_info = FTS_ERR;
344 } else
345 p->fts_flags |= FTS_SYMFOLLOW;
346 }
347 return (p);
348 }
349
350 /* Directory in pre-order. */
351 if (p->fts_info == FTS_D) {
352 /* If skipped or crossed mount point, do post-order visit. */
353 if (instr == FTS_SKIP ||
354 (ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev)) {
355 if (p->fts_flags & FTS_SYMFOLLOW)
356 (void)_close(p->fts_symfd);
357 if (sp->fts_child) {
358 fts_lfree(sp->fts_child);
359 sp->fts_child = NULL;
360 }
361 p->fts_info = FTS_DP;
362 return (p);
363 }
364
365 /* Rebuild if only read the names and now traversing. */
366 if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
367 CLR(FTS_NAMEONLY);
368 fts_lfree(sp->fts_child);
369 sp->fts_child = NULL;
370 }
371
372 /*
373 * Cd to the subdirectory.
374 *
375 * If have already read and now fail to chdir, whack the list
376 * to make the names come out right, and set the parent errno
377 * so the application will eventually get an error condition.
378 * Set the FTS_DONTCHDIR flag so that when we logically change
379 * directories back to the parent we don't do a chdir.
380 *
381 * If haven't read do so. If the read fails, fts_build sets
382 * FTS_STOP or the fts_info field of the node.
383 */
384 if (sp->fts_child != NULL) {
385 if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
386 p->fts_errno = errno;
387 p->fts_flags |= FTS_DONTCHDIR;
388 for (p = sp->fts_child; p != NULL;
389 p = p->fts_link)
390 p->fts_accpath =
391 p->fts_parent->fts_accpath;
392 }
393 } else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
394 if (ISSET(FTS_STOP))
395 return (NULL);
396 return (p);
397 }
398 p = sp->fts_child;
399 sp->fts_child = NULL;
400 goto name;
401 }
402
403 /* Move to the next node on this level. */
404next: tmp = p;
405 if ((p = p->fts_link) != NULL) {
406 free(tmp);
407
408 /*
409 * If reached the top, return to the original directory (or
410 * the root of the tree), and load the paths for the next root.
411 */
412 if (p->fts_level == FTS_ROOTLEVEL) {
413 if (FCHDIR(sp, sp->fts_rfd)) {
414 SET(FTS_STOP);
415 return (NULL);
416 }
417 fts_load(sp, p);
418 return (sp->fts_cur = p);
419 }
420
421 /*
422 * User may have called fts_set on the node. If skipped,
423 * ignore. If followed, get a file descriptor so we can
424 * get back if necessary.
425 */
426 if (p->fts_instr == FTS_SKIP)
427 goto next;
428 if (p->fts_instr == FTS_FOLLOW) {
429 p->fts_info = fts_stat(sp, p, 1);
430 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
431 if ((p->fts_symfd =
432 _open(".", O_RDONLY, 0)) < 0) {
433 p->fts_errno = errno;
434 p->fts_info = FTS_ERR;
435 } else
436 p->fts_flags |= FTS_SYMFOLLOW;
437 }
438 p->fts_instr = FTS_NOINSTR;
439 }
440
441name: t = sp->fts_path + NAPPEND(p->fts_parent);
442 *t++ = '/';
443 memmove(t, p->fts_name, p->fts_namelen + 1);
444 return (sp->fts_cur = p);
445 }
446
447 /* Move up to the parent node. */
448 p = tmp->fts_parent;
449 free(tmp);
450
451 if (p->fts_level == FTS_ROOTPARENTLEVEL) {
452 /*
453 * Done; free everything up and set errno to 0 so the user
454 * can distinguish between error and EOF.
455 */
456 free(p);
457 errno = 0;
458 return (sp->fts_cur = NULL);
459 }
460
461 /* NUL terminate the pathname. */
462 sp->fts_path[p->fts_pathlen] = '\0';
463
464 /*
465 * Return to the parent directory. If at a root node or came through
466 * a symlink, go back through the file descriptor. Otherwise, cd up
467 * one directory.
468 */
469 if (p->fts_level == FTS_ROOTLEVEL) {
470 if (FCHDIR(sp, sp->fts_rfd)) {
471 SET(FTS_STOP);
472 return (NULL);
473 }
474 } else if (p->fts_flags & FTS_SYMFOLLOW) {
475 if (FCHDIR(sp, p->fts_symfd)) {
476 saved_errno = errno;
477 (void)_close(p->fts_symfd);
478 errno = saved_errno;
479 SET(FTS_STOP);
480 return (NULL);
481 }
482 (void)_close(p->fts_symfd);
483 } else if (!(p->fts_flags & FTS_DONTCHDIR) &&
484 fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
485 SET(FTS_STOP);
486 return (NULL);
487 }
488 p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
489 return (sp->fts_cur = p);
490}
491
492/*
493 * Fts_set takes the stream as an argument although it's not used in this
494 * implementation; it would be necessary if anyone wanted to add global
495 * semantics to fts using fts_set. An error return is allowed for similar
496 * reasons.
497 */
498/* ARGSUSED */
499int
500fts_set(FTS *sp, FTSENT *p, int instr)
501{
502 if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
503 instr != FTS_NOINSTR && instr != FTS_SKIP) {
504 errno = EINVAL;
505 return (1);
506 }
507 p->fts_instr = instr;
508 return (0);
509}
510
511FTSENT *
512fts_children(FTS *sp, int instr)
513{
514 FTSENT *p;
515 int fd;
516
517 if (instr != 0 && instr != FTS_NAMEONLY) {
518 errno = EINVAL;
519 return (NULL);
520 }
521
522 /* Set current node pointer. */
523 p = sp->fts_cur;
524
525 /*
526 * Errno set to 0 so user can distinguish empty directory from
527 * an error.
528 */
529 errno = 0;
530
531 /* Fatal errors stop here. */
532 if (ISSET(FTS_STOP))
533 return (NULL);
534
535 /* Return logical hierarchy of user's arguments. */
536 if (p->fts_info == FTS_INIT)
537 return (p->fts_link);
538
539 /*
540 * If not a directory being visited in pre-order, stop here. Could
541 * allow FTS_DNR, assuming the user has fixed the problem, but the
542 * same effect is available with FTS_AGAIN.
543 */
544 if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
545 return (NULL);
546
547 /* Free up any previous child list. */
548 if (sp->fts_child != NULL)
549 fts_lfree(sp->fts_child);
550
551 if (instr == FTS_NAMEONLY) {
552 SET(FTS_NAMEONLY);
553 instr = BNAMES;
554 } else
555 instr = BCHILD;
556
557 /*
558 * If using chdir on a relative path and called BEFORE fts_read does
559 * its chdir to the root of a traversal, we can lose -- we need to
560 * chdir into the subdirectory, and we don't know where the current
561 * directory is, so we can't get back so that the upcoming chdir by
562 * fts_read will work.
563 */
564 if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
565 ISSET(FTS_NOCHDIR))
566 return (sp->fts_child = fts_build(sp, instr));
567
568 if ((fd = _open(".", O_RDONLY, 0)) < 0)
569 return (NULL);
570 sp->fts_child = fts_build(sp, instr);
571 if (fchdir(fd)) {
572 (void)_close(fd);
573 return (NULL);
574 }
575 (void)_close(fd);
576 return (sp->fts_child);
577}
578
579#ifndef fts_get_clientptr
580#error "fts_get_clientptr not defined"
581#endif
582
583void *
584(fts_get_clientptr)(FTS *sp)
585{
586
587 return (fts_get_clientptr(sp));
588}
589
590#ifndef fts_get_stream
591#error "fts_get_stream not defined"
592#endif
593
594FTS *
595(fts_get_stream)(FTSENT *p)
596{
597 return (fts_get_stream(p));
598}
599
600void
601fts_set_clientptr(FTS *sp, void *clientptr)
602{
603
604 sp->fts_clientptr = clientptr;
605}
606
607/*
608 * This is the tricky part -- do not casually change *anything* in here. The
609 * idea is to build the linked list of entries that are used by fts_children
610 * and fts_read. There are lots of special cases.
611 *
612 * The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is
613 * set and it's a physical walk (so that symbolic links can't be directories),
614 * we can do things quickly. First, if it's a 4.4BSD file system, the type
615 * of the file is in the directory entry. Otherwise, we assume that the number
616 * of subdirectories in a node is equal to the number of links to the parent.
617 * The former skips all stat calls. The latter skips stat calls in any leaf
618 * directories and for any files after the subdirectories in the directory have
619 * been found, cutting the stat calls by about 2/3.
620 */
621static FTSENT *
622fts_build(FTS *sp, int type)
623{
624 struct dirent *dp;
625 FTSENT *p, *head;
626 FTSENT *cur, *tail;
627 DIR *dirp;
628 void *oldaddr;
629 char *cp;
630 int cderrno, descend, oflag, saved_errno, nostat, doadjust;
631 long level;
632 long nlinks; /* has to be signed because -1 is a magic value */
633 size_t dnamlen, len, maxlen, nitems;
634
635 /* Set current node pointer. */
636 cur = sp->fts_cur;
637
638 /*
639 * Open the directory for reading. If this fails, we're done.
640 * If being called from fts_read, set the fts_info field.
641 */
642#ifdef FTS_WHITEOUT
643 if (ISSET(FTS_WHITEOUT))
644 oflag = DTF_NODUP | DTF_REWIND;
645 else
646 oflag = DTF_HIDEW | DTF_NODUP | DTF_REWIND;
647#else
648#define __opendir2(path, flag) opendir(path)
649#endif
650 if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
651 if (type == BREAD) {
652 cur->fts_info = FTS_DNR;
653 cur->fts_errno = errno;
654 }
655 return (NULL);
656 }
657
658 /*
659 * Nlinks is the number of possible entries of type directory in the
660 * directory if we're cheating on stat calls, 0 if we're not doing
661 * any stat calls at all, -1 if we're doing stats on everything.
662 */
663 if (type == BNAMES) {
664 nlinks = 0;
665 /* Be quiet about nostat, GCC. */
666 nostat = 0;
667 } else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
668 if (fts_ufslinks(sp, cur))
669 nlinks = cur->fts_nlink - (ISSET(FTS_SEEDOT) ? 0 : 2);
670 else
671 nlinks = -1;
672 nostat = 1;
673 } else {
674 nlinks = -1;
675 nostat = 0;
676 }
677
678#ifdef notdef
679 (void)printf("nlinks == %d (cur: %d)\n", nlinks, cur->fts_nlink);
680 (void)printf("NOSTAT %d PHYSICAL %d SEEDOT %d\n",
681 ISSET(FTS_NOSTAT), ISSET(FTS_PHYSICAL), ISSET(FTS_SEEDOT));
682#endif
683 /*
684 * If we're going to need to stat anything or we want to descend
685 * and stay in the directory, chdir. If this fails we keep going,
686 * but set a flag so we don't chdir after the post-order visit.
687 * We won't be able to stat anything, but we can still return the
688 * names themselves. Note, that since fts_read won't be able to
689 * chdir into the directory, it will have to return different path
690 * names than before, i.e. "a/b" instead of "b". Since the node
691 * has already been visited in pre-order, have to wait until the
692 * post-order visit to return the error. There is a special case
693 * here, if there was nothing to stat then it's not an error to
694 * not be able to stat. This is all fairly nasty. If a program
695 * needed sorted entries or stat information, they had better be
696 * checking FTS_NS on the returned nodes.
697 */
698 cderrno = 0;
699 if (nlinks || type == BREAD) {
| 57static FTSENT *fts_alloc(FTS *, char *, size_t);
58static FTSENT *fts_build(FTS *, int);
59static void fts_lfree(FTSENT *);
60static void fts_load(FTS *, FTSENT *);
61static size_t fts_maxarglen(char * const *);
62static void fts_padjust(FTS *, FTSENT *);
63static int fts_palloc(FTS *, size_t);
64static FTSENT *fts_sort(FTS *, FTSENT *, size_t);
65static int fts_stat(FTS *, FTSENT *, int);
66static int fts_safe_changedir(FTS *, FTSENT *, int, char *);
67static int fts_ufslinks(FTS *, const FTSENT *);
68
69#define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
70
71#define CLR(opt) (sp->fts_options &= ~(opt))
72#define ISSET(opt) (sp->fts_options & (opt))
73#define SET(opt) (sp->fts_options |= (opt))
74
75#define FCHDIR(sp, fd) (!ISSET(FTS_NOCHDIR) && fchdir(fd))
76
77/* fts_build flags */
78#define BCHILD 1 /* fts_children */
79#define BNAMES 2 /* fts_children, names only */
80#define BREAD 3 /* fts_read */
81
82/*
83 * Internal representation of an FTS, including extra implementation
84 * details. The FTS returned from fts_open points to this structure's
85 * ftsp_fts member (and can be cast to an _fts_private as required)
86 */
87struct _fts_private {
88 FTS ftsp_fts;
89 struct statfs ftsp_statfs;
90 dev_t ftsp_dev;
91 int ftsp_linksreliable;
92};
93
94/*
95 * The "FTS_NOSTAT" option can avoid a lot of calls to stat(2) if it
96 * knows that a directory could not possibly have subdirectories. This
97 * is decided by looking at the link count: a subdirectory would
98 * increment its parent's link count by virtue of its own ".." entry.
99 * This assumption only holds for UFS-like filesystems that implement
100 * links and directories this way, so we must punt for others.
101 */
102
103static const char *ufslike_filesystems[] = {
104 "ufs",
105 "zfs",
106 "nfs",
107 "nfs4",
108 "ext2fs",
109 0
110};
111
112FTS *
113fts_open(argv, options, compar)
114 char * const *argv;
115 int options;
116 int (*compar)(const FTSENT * const *, const FTSENT * const *);
117{
118 struct _fts_private *priv;
119 FTS *sp;
120 FTSENT *p, *root;
121 FTSENT *parent, *tmp;
122 size_t len, nitems;
123
124 /* Options check. */
125 if (options & ~FTS_OPTIONMASK) {
126 errno = EINVAL;
127 return (NULL);
128 }
129
130 /* fts_open() requires at least one path */
131 if (*argv == NULL) {
132 errno = EINVAL;
133 return (NULL);
134 }
135
136 /* Allocate/initialize the stream. */
137 if ((priv = malloc(sizeof(*priv))) == NULL)
138 return (NULL);
139 memset(priv, 0, sizeof(*priv));
140 sp = &priv->ftsp_fts;
141 sp->fts_compar = compar;
142 sp->fts_options = options;
143
144 /* Shush, GCC. */
145 tmp = NULL;
146
147 /* Logical walks turn on NOCHDIR; symbolic links are too hard. */
148 if (ISSET(FTS_LOGICAL))
149 SET(FTS_NOCHDIR);
150
151 /*
152 * Start out with 1K of path space, and enough, in any case,
153 * to hold the user's paths.
154 */
155 if (fts_palloc(sp, MAX(fts_maxarglen(argv), MAXPATHLEN)))
156 goto mem1;
157
158 /* Allocate/initialize root's parent. */
159 if ((parent = fts_alloc(sp, "", 0)) == NULL)
160 goto mem2;
161 parent->fts_level = FTS_ROOTPARENTLEVEL;
162
163 /* Allocate/initialize root(s). */
164 for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
165 /* Don't allow zero-length paths. */
166 if ((len = strlen(*argv)) == 0) {
167 errno = ENOENT;
168 goto mem3;
169 }
170
171 p = fts_alloc(sp, *argv, len);
172 p->fts_level = FTS_ROOTLEVEL;
173 p->fts_parent = parent;
174 p->fts_accpath = p->fts_name;
175 p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW));
176
177 /* Command-line "." and ".." are real directories. */
178 if (p->fts_info == FTS_DOT)
179 p->fts_info = FTS_D;
180
181 /*
182 * If comparison routine supplied, traverse in sorted
183 * order; otherwise traverse in the order specified.
184 */
185 if (compar) {
186 p->fts_link = root;
187 root = p;
188 } else {
189 p->fts_link = NULL;
190 if (root == NULL)
191 tmp = root = p;
192 else {
193 tmp->fts_link = p;
194 tmp = p;
195 }
196 }
197 }
198 if (compar && nitems > 1)
199 root = fts_sort(sp, root, nitems);
200
201 /*
202 * Allocate a dummy pointer and make fts_read think that we've just
203 * finished the node before the root(s); set p->fts_info to FTS_INIT
204 * so that everything about the "current" node is ignored.
205 */
206 if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
207 goto mem3;
208 sp->fts_cur->fts_link = root;
209 sp->fts_cur->fts_info = FTS_INIT;
210
211 /*
212 * If using chdir(2), grab a file descriptor pointing to dot to ensure
213 * that we can get back here; this could be avoided for some paths,
214 * but almost certainly not worth the effort. Slashes, symbolic links,
215 * and ".." are all fairly nasty problems. Note, if we can't get the
216 * descriptor we run anyway, just more slowly.
217 */
218 if (!ISSET(FTS_NOCHDIR) && (sp->fts_rfd = _open(".", O_RDONLY, 0)) < 0)
219 SET(FTS_NOCHDIR);
220
221 return (sp);
222
223mem3: fts_lfree(root);
224 free(parent);
225mem2: free(sp->fts_path);
226mem1: free(sp);
227 return (NULL);
228}
229
230static void
231fts_load(FTS *sp, FTSENT *p)
232{
233 size_t len;
234 char *cp;
235
236 /*
237 * Load the stream structure for the next traversal. Since we don't
238 * actually enter the directory until after the preorder visit, set
239 * the fts_accpath field specially so the chdir gets done to the right
240 * place and the user can access the first node. From fts_open it's
241 * known that the path will fit.
242 */
243 len = p->fts_pathlen = p->fts_namelen;
244 memmove(sp->fts_path, p->fts_name, len + 1);
245 if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
246 len = strlen(++cp);
247 memmove(p->fts_name, cp, len + 1);
248 p->fts_namelen = len;
249 }
250 p->fts_accpath = p->fts_path = sp->fts_path;
251 sp->fts_dev = p->fts_dev;
252}
253
254int
255fts_close(FTS *sp)
256{
257 FTSENT *freep, *p;
258 int saved_errno;
259
260 /*
261 * This still works if we haven't read anything -- the dummy structure
262 * points to the root list, so we step through to the end of the root
263 * list which has a valid parent pointer.
264 */
265 if (sp->fts_cur) {
266 for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
267 freep = p;
268 p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
269 free(freep);
270 }
271 free(p);
272 }
273
274 /* Free up child linked list, sort array, path buffer. */
275 if (sp->fts_child)
276 fts_lfree(sp->fts_child);
277 if (sp->fts_array)
278 free(sp->fts_array);
279 free(sp->fts_path);
280
281 /* Return to original directory, save errno if necessary. */
282 if (!ISSET(FTS_NOCHDIR)) {
283 saved_errno = fchdir(sp->fts_rfd) ? errno : 0;
284 (void)_close(sp->fts_rfd);
285
286 /* Set errno and return. */
287 if (saved_errno != 0) {
288 /* Free up the stream pointer. */
289 free(sp);
290 errno = saved_errno;
291 return (-1);
292 }
293 }
294
295 /* Free up the stream pointer. */
296 free(sp);
297 return (0);
298}
299
300/*
301 * Special case of "/" at the end of the path so that slashes aren't
302 * appended which would cause paths to be written as "....//foo".
303 */
304#define NAPPEND(p) \
305 (p->fts_path[p->fts_pathlen - 1] == '/' \
306 ? p->fts_pathlen - 1 : p->fts_pathlen)
307
308FTSENT *
309fts_read(FTS *sp)
310{
311 FTSENT *p, *tmp;
312 int instr;
313 char *t;
314 int saved_errno;
315
316 /* If finished or unrecoverable error, return NULL. */
317 if (sp->fts_cur == NULL || ISSET(FTS_STOP))
318 return (NULL);
319
320 /* Set current node pointer. */
321 p = sp->fts_cur;
322
323 /* Save and zero out user instructions. */
324 instr = p->fts_instr;
325 p->fts_instr = FTS_NOINSTR;
326
327 /* Any type of file may be re-visited; re-stat and re-turn. */
328 if (instr == FTS_AGAIN) {
329 p->fts_info = fts_stat(sp, p, 0);
330 return (p);
331 }
332
333 /*
334 * Following a symlink -- SLNONE test allows application to see
335 * SLNONE and recover. If indirecting through a symlink, have
336 * keep a pointer to current location. If unable to get that
337 * pointer, follow fails.
338 */
339 if (instr == FTS_FOLLOW &&
340 (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
341 p->fts_info = fts_stat(sp, p, 1);
342 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
343 if ((p->fts_symfd = _open(".", O_RDONLY, 0)) < 0) {
344 p->fts_errno = errno;
345 p->fts_info = FTS_ERR;
346 } else
347 p->fts_flags |= FTS_SYMFOLLOW;
348 }
349 return (p);
350 }
351
352 /* Directory in pre-order. */
353 if (p->fts_info == FTS_D) {
354 /* If skipped or crossed mount point, do post-order visit. */
355 if (instr == FTS_SKIP ||
356 (ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev)) {
357 if (p->fts_flags & FTS_SYMFOLLOW)
358 (void)_close(p->fts_symfd);
359 if (sp->fts_child) {
360 fts_lfree(sp->fts_child);
361 sp->fts_child = NULL;
362 }
363 p->fts_info = FTS_DP;
364 return (p);
365 }
366
367 /* Rebuild if only read the names and now traversing. */
368 if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
369 CLR(FTS_NAMEONLY);
370 fts_lfree(sp->fts_child);
371 sp->fts_child = NULL;
372 }
373
374 /*
375 * Cd to the subdirectory.
376 *
377 * If have already read and now fail to chdir, whack the list
378 * to make the names come out right, and set the parent errno
379 * so the application will eventually get an error condition.
380 * Set the FTS_DONTCHDIR flag so that when we logically change
381 * directories back to the parent we don't do a chdir.
382 *
383 * If haven't read do so. If the read fails, fts_build sets
384 * FTS_STOP or the fts_info field of the node.
385 */
386 if (sp->fts_child != NULL) {
387 if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
388 p->fts_errno = errno;
389 p->fts_flags |= FTS_DONTCHDIR;
390 for (p = sp->fts_child; p != NULL;
391 p = p->fts_link)
392 p->fts_accpath =
393 p->fts_parent->fts_accpath;
394 }
395 } else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
396 if (ISSET(FTS_STOP))
397 return (NULL);
398 return (p);
399 }
400 p = sp->fts_child;
401 sp->fts_child = NULL;
402 goto name;
403 }
404
405 /* Move to the next node on this level. */
406next: tmp = p;
407 if ((p = p->fts_link) != NULL) {
408 free(tmp);
409
410 /*
411 * If reached the top, return to the original directory (or
412 * the root of the tree), and load the paths for the next root.
413 */
414 if (p->fts_level == FTS_ROOTLEVEL) {
415 if (FCHDIR(sp, sp->fts_rfd)) {
416 SET(FTS_STOP);
417 return (NULL);
418 }
419 fts_load(sp, p);
420 return (sp->fts_cur = p);
421 }
422
423 /*
424 * User may have called fts_set on the node. If skipped,
425 * ignore. If followed, get a file descriptor so we can
426 * get back if necessary.
427 */
428 if (p->fts_instr == FTS_SKIP)
429 goto next;
430 if (p->fts_instr == FTS_FOLLOW) {
431 p->fts_info = fts_stat(sp, p, 1);
432 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
433 if ((p->fts_symfd =
434 _open(".", O_RDONLY, 0)) < 0) {
435 p->fts_errno = errno;
436 p->fts_info = FTS_ERR;
437 } else
438 p->fts_flags |= FTS_SYMFOLLOW;
439 }
440 p->fts_instr = FTS_NOINSTR;
441 }
442
443name: t = sp->fts_path + NAPPEND(p->fts_parent);
444 *t++ = '/';
445 memmove(t, p->fts_name, p->fts_namelen + 1);
446 return (sp->fts_cur = p);
447 }
448
449 /* Move up to the parent node. */
450 p = tmp->fts_parent;
451 free(tmp);
452
453 if (p->fts_level == FTS_ROOTPARENTLEVEL) {
454 /*
455 * Done; free everything up and set errno to 0 so the user
456 * can distinguish between error and EOF.
457 */
458 free(p);
459 errno = 0;
460 return (sp->fts_cur = NULL);
461 }
462
463 /* NUL terminate the pathname. */
464 sp->fts_path[p->fts_pathlen] = '\0';
465
466 /*
467 * Return to the parent directory. If at a root node or came through
468 * a symlink, go back through the file descriptor. Otherwise, cd up
469 * one directory.
470 */
471 if (p->fts_level == FTS_ROOTLEVEL) {
472 if (FCHDIR(sp, sp->fts_rfd)) {
473 SET(FTS_STOP);
474 return (NULL);
475 }
476 } else if (p->fts_flags & FTS_SYMFOLLOW) {
477 if (FCHDIR(sp, p->fts_symfd)) {
478 saved_errno = errno;
479 (void)_close(p->fts_symfd);
480 errno = saved_errno;
481 SET(FTS_STOP);
482 return (NULL);
483 }
484 (void)_close(p->fts_symfd);
485 } else if (!(p->fts_flags & FTS_DONTCHDIR) &&
486 fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
487 SET(FTS_STOP);
488 return (NULL);
489 }
490 p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
491 return (sp->fts_cur = p);
492}
493
494/*
495 * Fts_set takes the stream as an argument although it's not used in this
496 * implementation; it would be necessary if anyone wanted to add global
497 * semantics to fts using fts_set. An error return is allowed for similar
498 * reasons.
499 */
500/* ARGSUSED */
501int
502fts_set(FTS *sp, FTSENT *p, int instr)
503{
504 if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
505 instr != FTS_NOINSTR && instr != FTS_SKIP) {
506 errno = EINVAL;
507 return (1);
508 }
509 p->fts_instr = instr;
510 return (0);
511}
512
513FTSENT *
514fts_children(FTS *sp, int instr)
515{
516 FTSENT *p;
517 int fd;
518
519 if (instr != 0 && instr != FTS_NAMEONLY) {
520 errno = EINVAL;
521 return (NULL);
522 }
523
524 /* Set current node pointer. */
525 p = sp->fts_cur;
526
527 /*
528 * Errno set to 0 so user can distinguish empty directory from
529 * an error.
530 */
531 errno = 0;
532
533 /* Fatal errors stop here. */
534 if (ISSET(FTS_STOP))
535 return (NULL);
536
537 /* Return logical hierarchy of user's arguments. */
538 if (p->fts_info == FTS_INIT)
539 return (p->fts_link);
540
541 /*
542 * If not a directory being visited in pre-order, stop here. Could
543 * allow FTS_DNR, assuming the user has fixed the problem, but the
544 * same effect is available with FTS_AGAIN.
545 */
546 if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
547 return (NULL);
548
549 /* Free up any previous child list. */
550 if (sp->fts_child != NULL)
551 fts_lfree(sp->fts_child);
552
553 if (instr == FTS_NAMEONLY) {
554 SET(FTS_NAMEONLY);
555 instr = BNAMES;
556 } else
557 instr = BCHILD;
558
559 /*
560 * If using chdir on a relative path and called BEFORE fts_read does
561 * its chdir to the root of a traversal, we can lose -- we need to
562 * chdir into the subdirectory, and we don't know where the current
563 * directory is, so we can't get back so that the upcoming chdir by
564 * fts_read will work.
565 */
566 if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
567 ISSET(FTS_NOCHDIR))
568 return (sp->fts_child = fts_build(sp, instr));
569
570 if ((fd = _open(".", O_RDONLY, 0)) < 0)
571 return (NULL);
572 sp->fts_child = fts_build(sp, instr);
573 if (fchdir(fd)) {
574 (void)_close(fd);
575 return (NULL);
576 }
577 (void)_close(fd);
578 return (sp->fts_child);
579}
580
581#ifndef fts_get_clientptr
582#error "fts_get_clientptr not defined"
583#endif
584
585void *
586(fts_get_clientptr)(FTS *sp)
587{
588
589 return (fts_get_clientptr(sp));
590}
591
592#ifndef fts_get_stream
593#error "fts_get_stream not defined"
594#endif
595
596FTS *
597(fts_get_stream)(FTSENT *p)
598{
599 return (fts_get_stream(p));
600}
601
602void
603fts_set_clientptr(FTS *sp, void *clientptr)
604{
605
606 sp->fts_clientptr = clientptr;
607}
608
609/*
610 * This is the tricky part -- do not casually change *anything* in here. The
611 * idea is to build the linked list of entries that are used by fts_children
612 * and fts_read. There are lots of special cases.
613 *
614 * The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is
615 * set and it's a physical walk (so that symbolic links can't be directories),
616 * we can do things quickly. First, if it's a 4.4BSD file system, the type
617 * of the file is in the directory entry. Otherwise, we assume that the number
618 * of subdirectories in a node is equal to the number of links to the parent.
619 * The former skips all stat calls. The latter skips stat calls in any leaf
620 * directories and for any files after the subdirectories in the directory have
621 * been found, cutting the stat calls by about 2/3.
622 */
623static FTSENT *
624fts_build(FTS *sp, int type)
625{
626 struct dirent *dp;
627 FTSENT *p, *head;
628 FTSENT *cur, *tail;
629 DIR *dirp;
630 void *oldaddr;
631 char *cp;
632 int cderrno, descend, oflag, saved_errno, nostat, doadjust;
633 long level;
634 long nlinks; /* has to be signed because -1 is a magic value */
635 size_t dnamlen, len, maxlen, nitems;
636
637 /* Set current node pointer. */
638 cur = sp->fts_cur;
639
640 /*
641 * Open the directory for reading. If this fails, we're done.
642 * If being called from fts_read, set the fts_info field.
643 */
644#ifdef FTS_WHITEOUT
645 if (ISSET(FTS_WHITEOUT))
646 oflag = DTF_NODUP | DTF_REWIND;
647 else
648 oflag = DTF_HIDEW | DTF_NODUP | DTF_REWIND;
649#else
650#define __opendir2(path, flag) opendir(path)
651#endif
652 if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
653 if (type == BREAD) {
654 cur->fts_info = FTS_DNR;
655 cur->fts_errno = errno;
656 }
657 return (NULL);
658 }
659
660 /*
661 * Nlinks is the number of possible entries of type directory in the
662 * directory if we're cheating on stat calls, 0 if we're not doing
663 * any stat calls at all, -1 if we're doing stats on everything.
664 */
665 if (type == BNAMES) {
666 nlinks = 0;
667 /* Be quiet about nostat, GCC. */
668 nostat = 0;
669 } else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
670 if (fts_ufslinks(sp, cur))
671 nlinks = cur->fts_nlink - (ISSET(FTS_SEEDOT) ? 0 : 2);
672 else
673 nlinks = -1;
674 nostat = 1;
675 } else {
676 nlinks = -1;
677 nostat = 0;
678 }
679
680#ifdef notdef
681 (void)printf("nlinks == %d (cur: %d)\n", nlinks, cur->fts_nlink);
682 (void)printf("NOSTAT %d PHYSICAL %d SEEDOT %d\n",
683 ISSET(FTS_NOSTAT), ISSET(FTS_PHYSICAL), ISSET(FTS_SEEDOT));
684#endif
685 /*
686 * If we're going to need to stat anything or we want to descend
687 * and stay in the directory, chdir. If this fails we keep going,
688 * but set a flag so we don't chdir after the post-order visit.
689 * We won't be able to stat anything, but we can still return the
690 * names themselves. Note, that since fts_read won't be able to
691 * chdir into the directory, it will have to return different path
692 * names than before, i.e. "a/b" instead of "b". Since the node
693 * has already been visited in pre-order, have to wait until the
694 * post-order visit to return the error. There is a special case
695 * here, if there was nothing to stat then it's not an error to
696 * not be able to stat. This is all fairly nasty. If a program
697 * needed sorted entries or stat information, they had better be
698 * checking FTS_NS on the returned nodes.
699 */
700 cderrno = 0;
701 if (nlinks || type == BREAD) {
|
701 if (nlinks && type == BREAD)
702 cur->fts_errno = errno;
703 cur->fts_flags |= FTS_DONTCHDIR;
704 descend = 0;
705 cderrno = errno;
706 } else
707 descend = 1;
708 } else
709 descend = 0;
710
711 /*
712 * Figure out the max file name length that can be stored in the
713 * current path -- the inner loop allocates more path as necessary.
714 * We really wouldn't have to do the maxlen calculations here, we
715 * could do them in fts_read before returning the path, but it's a
716 * lot easier here since the length is part of the dirent structure.
717 *
718 * If not changing directories set a pointer so that can just append
719 * each new name into the path.
720 */
721 len = NAPPEND(cur);
722 if (ISSET(FTS_NOCHDIR)) {
723 cp = sp->fts_path + len;
724 *cp++ = '/';
725 } else {
726 /* GCC, you're too verbose. */
727 cp = NULL;
728 }
729 len++;
730 maxlen = sp->fts_pathlen - len;
731
732 level = cur->fts_level + 1;
733
734 /* Read the directory, attaching each entry to the `link' pointer. */
735 doadjust = 0;
736 for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {
737 dnamlen = dp->d_namlen;
738 if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
739 continue;
740
741 if ((p = fts_alloc(sp, dp->d_name, dnamlen)) == NULL)
742 goto mem1;
743 if (dnamlen >= maxlen) { /* include space for NUL */
744 oldaddr = sp->fts_path;
745 if (fts_palloc(sp, dnamlen + len + 1)) {
746 /*
747 * No more memory for path or structures. Save
748 * errno, free up the current structure and the
749 * structures already allocated.
750 */
751mem1: saved_errno = errno;
752 if (p)
753 free(p);
754 fts_lfree(head);
755 (void)closedir(dirp);
756 cur->fts_info = FTS_ERR;
757 SET(FTS_STOP);
758 errno = saved_errno;
759 return (NULL);
760 }
761 /* Did realloc() change the pointer? */
762 if (oldaddr != sp->fts_path) {
763 doadjust = 1;
764 if (ISSET(FTS_NOCHDIR))
765 cp = sp->fts_path + len;
766 }
767 maxlen = sp->fts_pathlen - len;
768 }
769
770 p->fts_level = level;
771 p->fts_parent = sp->fts_cur;
772 p->fts_pathlen = len + dnamlen;
773
774#ifdef FTS_WHITEOUT
775 if (dp->d_type == DT_WHT)
776 p->fts_flags |= FTS_ISW;
777#endif
778
779 if (cderrno) {
780 if (nlinks) {
781 p->fts_info = FTS_NS;
782 p->fts_errno = cderrno;
783 } else
784 p->fts_info = FTS_NSOK;
785 p->fts_accpath = cur->fts_accpath;
786 } else if (nlinks == 0
787#ifdef DT_DIR
788 || (nostat &&
789 dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
790#endif
791 ) {
792 p->fts_accpath =
793 ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
794 p->fts_info = FTS_NSOK;
795 } else {
796 /* Build a file name for fts_stat to stat. */
797 if (ISSET(FTS_NOCHDIR)) {
798 p->fts_accpath = p->fts_path;
799 memmove(cp, p->fts_name, p->fts_namelen + 1);
800 } else
801 p->fts_accpath = p->fts_name;
802 /* Stat it. */
803 p->fts_info = fts_stat(sp, p, 0);
804
805 /* Decrement link count if applicable. */
806 if (nlinks > 0 && (p->fts_info == FTS_D ||
807 p->fts_info == FTS_DC || p->fts_info == FTS_DOT))
808 --nlinks;
809 }
810
811 /* We walk in directory order so "ls -f" doesn't get upset. */
812 p->fts_link = NULL;
813 if (head == NULL)
814 head = tail = p;
815 else {
816 tail->fts_link = p;
817 tail = p;
818 }
819 ++nitems;
820 }
821 if (dirp)
822 (void)closedir(dirp);
823
824 /*
825 * If realloc() changed the address of the path, adjust the
826 * addresses for the rest of the tree and the dir list.
827 */
828 if (doadjust)
829 fts_padjust(sp, head);
830
831 /*
832 * If not changing directories, reset the path back to original
833 * state.
834 */
835 if (ISSET(FTS_NOCHDIR))
836 sp->fts_path[cur->fts_pathlen] = '\0';
837
838 /*
839 * If descended after called from fts_children or after called from
840 * fts_read and nothing found, get back. At the root level we use
841 * the saved fd; if one of fts_open()'s arguments is a relative path
842 * to an empty directory, we wind up here with no other way back. If
843 * can't get back, we're done.
844 */
845 if (descend && (type == BCHILD || !nitems) &&
846 (cur->fts_level == FTS_ROOTLEVEL ?
847 FCHDIR(sp, sp->fts_rfd) :
848 fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
849 cur->fts_info = FTS_ERR;
850 SET(FTS_STOP);
851 return (NULL);
852 }
853
854 /* If didn't find anything, return NULL. */
855 if (!nitems) {
856 if (type == BREAD)
857 cur->fts_info = FTS_DP;
858 return (NULL);
859 }
860
861 /* Sort the entries. */
862 if (sp->fts_compar && nitems > 1)
863 head = fts_sort(sp, head, nitems);
864 return (head);
865}
866
867static int
868fts_stat(FTS *sp, FTSENT *p, int follow)
869{
870 FTSENT *t;
871 dev_t dev;
872 ino_t ino;
873 struct stat *sbp, sb;
874 int saved_errno;
875
876 /* If user needs stat info, stat buffer already allocated. */
877 sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
878
879#ifdef FTS_WHITEOUT
880 /* Check for whiteout. */
881 if (p->fts_flags & FTS_ISW) {
882 if (sbp != &sb) {
883 memset(sbp, '\0', sizeof(*sbp));
884 sbp->st_mode = S_IFWHT;
885 }
886 return (FTS_W);
887 }
888#endif
889
890 /*
891 * If doing a logical walk, or application requested FTS_FOLLOW, do
892 * a stat(2). If that fails, check for a non-existent symlink. If
893 * fail, set the errno from the stat call.
894 */
895 if (ISSET(FTS_LOGICAL) || follow) {
896 if (stat(p->fts_accpath, sbp)) {
897 saved_errno = errno;
898 if (!lstat(p->fts_accpath, sbp)) {
899 errno = 0;
900 return (FTS_SLNONE);
901 }
902 p->fts_errno = saved_errno;
903 goto err;
904 }
905 } else if (lstat(p->fts_accpath, sbp)) {
906 p->fts_errno = errno;
907err: memset(sbp, 0, sizeof(struct stat));
908 return (FTS_NS);
909 }
910
911 if (S_ISDIR(sbp->st_mode)) {
912 /*
913 * Set the device/inode. Used to find cycles and check for
914 * crossing mount points. Also remember the link count, used
915 * in fts_build to limit the number of stat calls. It is
916 * understood that these fields are only referenced if fts_info
917 * is set to FTS_D.
918 */
919 dev = p->fts_dev = sbp->st_dev;
920 ino = p->fts_ino = sbp->st_ino;
921 p->fts_nlink = sbp->st_nlink;
922
923 if (ISDOT(p->fts_name))
924 return (FTS_DOT);
925
926 /*
927 * Cycle detection is done by brute force when the directory
928 * is first encountered. If the tree gets deep enough or the
929 * number of symbolic links to directories is high enough,
930 * something faster might be worthwhile.
931 */
932 for (t = p->fts_parent;
933 t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
934 if (ino == t->fts_ino && dev == t->fts_dev) {
935 p->fts_cycle = t;
936 return (FTS_DC);
937 }
938 return (FTS_D);
939 }
940 if (S_ISLNK(sbp->st_mode))
941 return (FTS_SL);
942 if (S_ISREG(sbp->st_mode))
943 return (FTS_F);
944 return (FTS_DEFAULT);
945}
946
947/*
948 * The comparison function takes pointers to pointers to FTSENT structures.
949 * Qsort wants a comparison function that takes pointers to void.
950 * (Both with appropriate levels of const-poisoning, of course!)
951 * Use a trampoline function to deal with the difference.
952 */
953static int
954fts_compar(const void *a, const void *b)
955{
956 FTS *parent;
957
958 parent = (*(const FTSENT * const *)a)->fts_fts;
959 return (*parent->fts_compar)(a, b);
960}
961
962static FTSENT *
963fts_sort(FTS *sp, FTSENT *head, size_t nitems)
964{
965 FTSENT **ap, *p;
966
967 /*
968 * Construct an array of pointers to the structures and call qsort(3).
969 * Reassemble the array in the order returned by qsort. If unable to
970 * sort for memory reasons, return the directory entries in their
971 * current order. Allocate enough space for the current needs plus
972 * 40 so don't realloc one entry at a time.
973 */
974 if (nitems > sp->fts_nitems) {
975 sp->fts_nitems = nitems + 40;
976 if ((sp->fts_array = reallocf(sp->fts_array,
977 sp->fts_nitems * sizeof(FTSENT *))) == NULL) {
978 sp->fts_nitems = 0;
979 return (head);
980 }
981 }
982 for (ap = sp->fts_array, p = head; p; p = p->fts_link)
983 *ap++ = p;
984 qsort(sp->fts_array, nitems, sizeof(FTSENT *), fts_compar);
985 for (head = *(ap = sp->fts_array); --nitems; ++ap)
986 ap[0]->fts_link = ap[1];
987 ap[0]->fts_link = NULL;
988 return (head);
989}
990
991static FTSENT *
992fts_alloc(FTS *sp, char *name, size_t namelen)
993{
994 FTSENT *p;
995 size_t len;
996
997 struct ftsent_withstat {
998 FTSENT ent;
999 struct stat statbuf;
1000 };
1001
1002 /*
1003 * The file name is a variable length array and no stat structure is
1004 * necessary if the user has set the nostat bit. Allocate the FTSENT
1005 * structure, the file name and the stat structure in one chunk, but
1006 * be careful that the stat structure is reasonably aligned.
1007 */
1008 if (ISSET(FTS_NOSTAT))
1009 len = sizeof(FTSENT) + namelen + 1;
1010 else
1011 len = sizeof(struct ftsent_withstat) + namelen + 1;
1012
1013 if ((p = malloc(len)) == NULL)
1014 return (NULL);
1015
1016 if (ISSET(FTS_NOSTAT)) {
1017 p->fts_name = (char *)(p + 1);
1018 p->fts_statp = NULL;
1019 } else {
1020 p->fts_name = (char *)((struct ftsent_withstat *)p + 1);
1021 p->fts_statp = &((struct ftsent_withstat *)p)->statbuf;
1022 }
1023
1024 /* Copy the name and guarantee NUL termination. */
1025 memcpy(p->fts_name, name, namelen);
1026 p->fts_name[namelen] = '\0';
1027 p->fts_namelen = namelen;
1028 p->fts_path = sp->fts_path;
1029 p->fts_errno = 0;
1030 p->fts_flags = 0;
1031 p->fts_instr = FTS_NOINSTR;
1032 p->fts_number = 0;
1033 p->fts_pointer = NULL;
1034 p->fts_fts = sp;
1035 return (p);
1036}
1037
1038static void
1039fts_lfree(FTSENT *head)
1040{
1041 FTSENT *p;
1042
1043 /* Free a linked list of structures. */
1044 while ((p = head)) {
1045 head = head->fts_link;
1046 free(p);
1047 }
1048}
1049
1050/*
1051 * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
1052 * Most systems will allow creation of paths much longer than MAXPATHLEN, even
1053 * though the kernel won't resolve them. Add the size (not just what's needed)
1054 * plus 256 bytes so don't realloc the path 2 bytes at a time.
1055 */
1056static int
1057fts_palloc(FTS *sp, size_t more)
1058{
1059
1060 sp->fts_pathlen += more + 256;
1061 sp->fts_path = reallocf(sp->fts_path, sp->fts_pathlen);
1062 return (sp->fts_path == NULL);
1063}
1064
1065/*
1066 * When the path is realloc'd, have to fix all of the pointers in structures
1067 * already returned.
1068 */
1069static void
1070fts_padjust(FTS *sp, FTSENT *head)
1071{
1072 FTSENT *p;
1073 char *addr = sp->fts_path;
1074
1075#define ADJUST(p) do { \
1076 if ((p)->fts_accpath != (p)->fts_name) { \
1077 (p)->fts_accpath = \
1078 (char *)addr + ((p)->fts_accpath - (p)->fts_path); \
1079 } \
1080 (p)->fts_path = addr; \
1081} while (0)
1082 /* Adjust the current set of children. */
1083 for (p = sp->fts_child; p; p = p->fts_link)
1084 ADJUST(p);
1085
1086 /* Adjust the rest of the tree, including the current level. */
1087 for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
1088 ADJUST(p);
1089 p = p->fts_link ? p->fts_link : p->fts_parent;
1090 }
1091}
1092
1093static size_t
1094fts_maxarglen(argv)
1095 char * const *argv;
1096{
1097 size_t len, max;
1098
1099 for (max = 0; *argv; ++argv)
1100 if ((len = strlen(*argv)) > max)
1101 max = len;
1102 return (max + 1);
1103}
1104
1105/*
1106 * Change to dir specified by fd or p->fts_accpath without getting
1107 * tricked by someone changing the world out from underneath us.
1108 * Assumes p->fts_dev and p->fts_ino are filled in.
1109 */
1110static int
1111fts_safe_changedir(FTS *sp, FTSENT *p, int fd, char *path)
1112{
1113 int ret, oerrno, newfd;
1114 struct stat sb;
1115
1116 newfd = fd;
1117 if (ISSET(FTS_NOCHDIR))
1118 return (0);
1119 if (fd < 0 && (newfd = _open(path, O_RDONLY, 0)) < 0)
1120 return (-1);
1121 if (_fstat(newfd, &sb)) {
1122 ret = -1;
1123 goto bail;
1124 }
1125 if (p->fts_dev != sb.st_dev || p->fts_ino != sb.st_ino) {
1126 errno = ENOENT; /* disinformation */
1127 ret = -1;
1128 goto bail;
1129 }
1130 ret = fchdir(newfd);
1131bail:
1132 oerrno = errno;
1133 if (fd < 0)
1134 (void)_close(newfd);
1135 errno = oerrno;
1136 return (ret);
1137}
1138
1139/*
1140 * Check if the filesystem for "ent" has UFS-style links.
1141 */
1142static int
1143fts_ufslinks(FTS *sp, const FTSENT *ent)
1144{
1145 struct _fts_private *priv;
1146 const char **cpp;
1147
1148 priv = (struct _fts_private *)sp;
1149 /*
1150 * If this node's device is different from the previous, grab
1151 * the filesystem information, and decide on the reliability
1152 * of the link information from this filesystem for stat(2)
1153 * avoidance.
1154 */
1155 if (priv->ftsp_dev != ent->fts_dev) {
1156 if (statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {
1157 priv->ftsp_dev = ent->fts_dev;
1158 priv->ftsp_linksreliable = 0;
1159 for (cpp = ufslike_filesystems; *cpp; cpp++) {
1160 if (strcmp(priv->ftsp_statfs.f_fstypename,
1161 *cpp) == 0) {
1162 priv->ftsp_linksreliable = 1;
1163 break;
1164 }
1165 }
1166 } else {
1167 priv->ftsp_linksreliable = 0;
1168 }
1169 }
1170 return (priv->ftsp_linksreliable);
1171}
| 703 if (nlinks && type == BREAD)
704 cur->fts_errno = errno;
705 cur->fts_flags |= FTS_DONTCHDIR;
706 descend = 0;
707 cderrno = errno;
708 } else
709 descend = 1;
710 } else
711 descend = 0;
712
713 /*
714 * Figure out the max file name length that can be stored in the
715 * current path -- the inner loop allocates more path as necessary.
716 * We really wouldn't have to do the maxlen calculations here, we
717 * could do them in fts_read before returning the path, but it's a
718 * lot easier here since the length is part of the dirent structure.
719 *
720 * If not changing directories set a pointer so that can just append
721 * each new name into the path.
722 */
723 len = NAPPEND(cur);
724 if (ISSET(FTS_NOCHDIR)) {
725 cp = sp->fts_path + len;
726 *cp++ = '/';
727 } else {
728 /* GCC, you're too verbose. */
729 cp = NULL;
730 }
731 len++;
732 maxlen = sp->fts_pathlen - len;
733
734 level = cur->fts_level + 1;
735
736 /* Read the directory, attaching each entry to the `link' pointer. */
737 doadjust = 0;
738 for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {
739 dnamlen = dp->d_namlen;
740 if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
741 continue;
742
743 if ((p = fts_alloc(sp, dp->d_name, dnamlen)) == NULL)
744 goto mem1;
745 if (dnamlen >= maxlen) { /* include space for NUL */
746 oldaddr = sp->fts_path;
747 if (fts_palloc(sp, dnamlen + len + 1)) {
748 /*
749 * No more memory for path or structures. Save
750 * errno, free up the current structure and the
751 * structures already allocated.
752 */
753mem1: saved_errno = errno;
754 if (p)
755 free(p);
756 fts_lfree(head);
757 (void)closedir(dirp);
758 cur->fts_info = FTS_ERR;
759 SET(FTS_STOP);
760 errno = saved_errno;
761 return (NULL);
762 }
763 /* Did realloc() change the pointer? */
764 if (oldaddr != sp->fts_path) {
765 doadjust = 1;
766 if (ISSET(FTS_NOCHDIR))
767 cp = sp->fts_path + len;
768 }
769 maxlen = sp->fts_pathlen - len;
770 }
771
772 p->fts_level = level;
773 p->fts_parent = sp->fts_cur;
774 p->fts_pathlen = len + dnamlen;
775
776#ifdef FTS_WHITEOUT
777 if (dp->d_type == DT_WHT)
778 p->fts_flags |= FTS_ISW;
779#endif
780
781 if (cderrno) {
782 if (nlinks) {
783 p->fts_info = FTS_NS;
784 p->fts_errno = cderrno;
785 } else
786 p->fts_info = FTS_NSOK;
787 p->fts_accpath = cur->fts_accpath;
788 } else if (nlinks == 0
789#ifdef DT_DIR
790 || (nostat &&
791 dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
792#endif
793 ) {
794 p->fts_accpath =
795 ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
796 p->fts_info = FTS_NSOK;
797 } else {
798 /* Build a file name for fts_stat to stat. */
799 if (ISSET(FTS_NOCHDIR)) {
800 p->fts_accpath = p->fts_path;
801 memmove(cp, p->fts_name, p->fts_namelen + 1);
802 } else
803 p->fts_accpath = p->fts_name;
804 /* Stat it. */
805 p->fts_info = fts_stat(sp, p, 0);
806
807 /* Decrement link count if applicable. */
808 if (nlinks > 0 && (p->fts_info == FTS_D ||
809 p->fts_info == FTS_DC || p->fts_info == FTS_DOT))
810 --nlinks;
811 }
812
813 /* We walk in directory order so "ls -f" doesn't get upset. */
814 p->fts_link = NULL;
815 if (head == NULL)
816 head = tail = p;
817 else {
818 tail->fts_link = p;
819 tail = p;
820 }
821 ++nitems;
822 }
823 if (dirp)
824 (void)closedir(dirp);
825
826 /*
827 * If realloc() changed the address of the path, adjust the
828 * addresses for the rest of the tree and the dir list.
829 */
830 if (doadjust)
831 fts_padjust(sp, head);
832
833 /*
834 * If not changing directories, reset the path back to original
835 * state.
836 */
837 if (ISSET(FTS_NOCHDIR))
838 sp->fts_path[cur->fts_pathlen] = '\0';
839
840 /*
841 * If descended after called from fts_children or after called from
842 * fts_read and nothing found, get back. At the root level we use
843 * the saved fd; if one of fts_open()'s arguments is a relative path
844 * to an empty directory, we wind up here with no other way back. If
845 * can't get back, we're done.
846 */
847 if (descend && (type == BCHILD || !nitems) &&
848 (cur->fts_level == FTS_ROOTLEVEL ?
849 FCHDIR(sp, sp->fts_rfd) :
850 fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
851 cur->fts_info = FTS_ERR;
852 SET(FTS_STOP);
853 return (NULL);
854 }
855
856 /* If didn't find anything, return NULL. */
857 if (!nitems) {
858 if (type == BREAD)
859 cur->fts_info = FTS_DP;
860 return (NULL);
861 }
862
863 /* Sort the entries. */
864 if (sp->fts_compar && nitems > 1)
865 head = fts_sort(sp, head, nitems);
866 return (head);
867}
868
869static int
870fts_stat(FTS *sp, FTSENT *p, int follow)
871{
872 FTSENT *t;
873 dev_t dev;
874 ino_t ino;
875 struct stat *sbp, sb;
876 int saved_errno;
877
878 /* If user needs stat info, stat buffer already allocated. */
879 sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
880
881#ifdef FTS_WHITEOUT
882 /* Check for whiteout. */
883 if (p->fts_flags & FTS_ISW) {
884 if (sbp != &sb) {
885 memset(sbp, '\0', sizeof(*sbp));
886 sbp->st_mode = S_IFWHT;
887 }
888 return (FTS_W);
889 }
890#endif
891
892 /*
893 * If doing a logical walk, or application requested FTS_FOLLOW, do
894 * a stat(2). If that fails, check for a non-existent symlink. If
895 * fail, set the errno from the stat call.
896 */
897 if (ISSET(FTS_LOGICAL) || follow) {
898 if (stat(p->fts_accpath, sbp)) {
899 saved_errno = errno;
900 if (!lstat(p->fts_accpath, sbp)) {
901 errno = 0;
902 return (FTS_SLNONE);
903 }
904 p->fts_errno = saved_errno;
905 goto err;
906 }
907 } else if (lstat(p->fts_accpath, sbp)) {
908 p->fts_errno = errno;
909err: memset(sbp, 0, sizeof(struct stat));
910 return (FTS_NS);
911 }
912
913 if (S_ISDIR(sbp->st_mode)) {
914 /*
915 * Set the device/inode. Used to find cycles and check for
916 * crossing mount points. Also remember the link count, used
917 * in fts_build to limit the number of stat calls. It is
918 * understood that these fields are only referenced if fts_info
919 * is set to FTS_D.
920 */
921 dev = p->fts_dev = sbp->st_dev;
922 ino = p->fts_ino = sbp->st_ino;
923 p->fts_nlink = sbp->st_nlink;
924
925 if (ISDOT(p->fts_name))
926 return (FTS_DOT);
927
928 /*
929 * Cycle detection is done by brute force when the directory
930 * is first encountered. If the tree gets deep enough or the
931 * number of symbolic links to directories is high enough,
932 * something faster might be worthwhile.
933 */
934 for (t = p->fts_parent;
935 t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
936 if (ino == t->fts_ino && dev == t->fts_dev) {
937 p->fts_cycle = t;
938 return (FTS_DC);
939 }
940 return (FTS_D);
941 }
942 if (S_ISLNK(sbp->st_mode))
943 return (FTS_SL);
944 if (S_ISREG(sbp->st_mode))
945 return (FTS_F);
946 return (FTS_DEFAULT);
947}
948
949/*
950 * The comparison function takes pointers to pointers to FTSENT structures.
951 * Qsort wants a comparison function that takes pointers to void.
952 * (Both with appropriate levels of const-poisoning, of course!)
953 * Use a trampoline function to deal with the difference.
954 */
955static int
956fts_compar(const void *a, const void *b)
957{
958 FTS *parent;
959
960 parent = (*(const FTSENT * const *)a)->fts_fts;
961 return (*parent->fts_compar)(a, b);
962}
963
964static FTSENT *
965fts_sort(FTS *sp, FTSENT *head, size_t nitems)
966{
967 FTSENT **ap, *p;
968
969 /*
970 * Construct an array of pointers to the structures and call qsort(3).
971 * Reassemble the array in the order returned by qsort. If unable to
972 * sort for memory reasons, return the directory entries in their
973 * current order. Allocate enough space for the current needs plus
974 * 40 so don't realloc one entry at a time.
975 */
976 if (nitems > sp->fts_nitems) {
977 sp->fts_nitems = nitems + 40;
978 if ((sp->fts_array = reallocf(sp->fts_array,
979 sp->fts_nitems * sizeof(FTSENT *))) == NULL) {
980 sp->fts_nitems = 0;
981 return (head);
982 }
983 }
984 for (ap = sp->fts_array, p = head; p; p = p->fts_link)
985 *ap++ = p;
986 qsort(sp->fts_array, nitems, sizeof(FTSENT *), fts_compar);
987 for (head = *(ap = sp->fts_array); --nitems; ++ap)
988 ap[0]->fts_link = ap[1];
989 ap[0]->fts_link = NULL;
990 return (head);
991}
992
993static FTSENT *
994fts_alloc(FTS *sp, char *name, size_t namelen)
995{
996 FTSENT *p;
997 size_t len;
998
999 struct ftsent_withstat {
1000 FTSENT ent;
1001 struct stat statbuf;
1002 };
1003
1004 /*
1005 * The file name is a variable length array and no stat structure is
1006 * necessary if the user has set the nostat bit. Allocate the FTSENT
1007 * structure, the file name and the stat structure in one chunk, but
1008 * be careful that the stat structure is reasonably aligned.
1009 */
1010 if (ISSET(FTS_NOSTAT))
1011 len = sizeof(FTSENT) + namelen + 1;
1012 else
1013 len = sizeof(struct ftsent_withstat) + namelen + 1;
1014
1015 if ((p = malloc(len)) == NULL)
1016 return (NULL);
1017
1018 if (ISSET(FTS_NOSTAT)) {
1019 p->fts_name = (char *)(p + 1);
1020 p->fts_statp = NULL;
1021 } else {
1022 p->fts_name = (char *)((struct ftsent_withstat *)p + 1);
1023 p->fts_statp = &((struct ftsent_withstat *)p)->statbuf;
1024 }
1025
1026 /* Copy the name and guarantee NUL termination. */
1027 memcpy(p->fts_name, name, namelen);
1028 p->fts_name[namelen] = '\0';
1029 p->fts_namelen = namelen;
1030 p->fts_path = sp->fts_path;
1031 p->fts_errno = 0;
1032 p->fts_flags = 0;
1033 p->fts_instr = FTS_NOINSTR;
1034 p->fts_number = 0;
1035 p->fts_pointer = NULL;
1036 p->fts_fts = sp;
1037 return (p);
1038}
1039
1040static void
1041fts_lfree(FTSENT *head)
1042{
1043 FTSENT *p;
1044
1045 /* Free a linked list of structures. */
1046 while ((p = head)) {
1047 head = head->fts_link;
1048 free(p);
1049 }
1050}
1051
1052/*
1053 * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
1054 * Most systems will allow creation of paths much longer than MAXPATHLEN, even
1055 * though the kernel won't resolve them. Add the size (not just what's needed)
1056 * plus 256 bytes so don't realloc the path 2 bytes at a time.
1057 */
1058static int
1059fts_palloc(FTS *sp, size_t more)
1060{
1061
1062 sp->fts_pathlen += more + 256;
1063 sp->fts_path = reallocf(sp->fts_path, sp->fts_pathlen);
1064 return (sp->fts_path == NULL);
1065}
1066
1067/*
1068 * When the path is realloc'd, have to fix all of the pointers in structures
1069 * already returned.
1070 */
1071static void
1072fts_padjust(FTS *sp, FTSENT *head)
1073{
1074 FTSENT *p;
1075 char *addr = sp->fts_path;
1076
1077#define ADJUST(p) do { \
1078 if ((p)->fts_accpath != (p)->fts_name) { \
1079 (p)->fts_accpath = \
1080 (char *)addr + ((p)->fts_accpath - (p)->fts_path); \
1081 } \
1082 (p)->fts_path = addr; \
1083} while (0)
1084 /* Adjust the current set of children. */
1085 for (p = sp->fts_child; p; p = p->fts_link)
1086 ADJUST(p);
1087
1088 /* Adjust the rest of the tree, including the current level. */
1089 for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
1090 ADJUST(p);
1091 p = p->fts_link ? p->fts_link : p->fts_parent;
1092 }
1093}
1094
1095static size_t
1096fts_maxarglen(argv)
1097 char * const *argv;
1098{
1099 size_t len, max;
1100
1101 for (max = 0; *argv; ++argv)
1102 if ((len = strlen(*argv)) > max)
1103 max = len;
1104 return (max + 1);
1105}
1106
1107/*
1108 * Change to dir specified by fd or p->fts_accpath without getting
1109 * tricked by someone changing the world out from underneath us.
1110 * Assumes p->fts_dev and p->fts_ino are filled in.
1111 */
1112static int
1113fts_safe_changedir(FTS *sp, FTSENT *p, int fd, char *path)
1114{
1115 int ret, oerrno, newfd;
1116 struct stat sb;
1117
1118 newfd = fd;
1119 if (ISSET(FTS_NOCHDIR))
1120 return (0);
1121 if (fd < 0 && (newfd = _open(path, O_RDONLY, 0)) < 0)
1122 return (-1);
1123 if (_fstat(newfd, &sb)) {
1124 ret = -1;
1125 goto bail;
1126 }
1127 if (p->fts_dev != sb.st_dev || p->fts_ino != sb.st_ino) {
1128 errno = ENOENT; /* disinformation */
1129 ret = -1;
1130 goto bail;
1131 }
1132 ret = fchdir(newfd);
1133bail:
1134 oerrno = errno;
1135 if (fd < 0)
1136 (void)_close(newfd);
1137 errno = oerrno;
1138 return (ret);
1139}
1140
1141/*
1142 * Check if the filesystem for "ent" has UFS-style links.
1143 */
1144static int
1145fts_ufslinks(FTS *sp, const FTSENT *ent)
1146{
1147 struct _fts_private *priv;
1148 const char **cpp;
1149
1150 priv = (struct _fts_private *)sp;
1151 /*
1152 * If this node's device is different from the previous, grab
1153 * the filesystem information, and decide on the reliability
1154 * of the link information from this filesystem for stat(2)
1155 * avoidance.
1156 */
1157 if (priv->ftsp_dev != ent->fts_dev) {
1158 if (statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {
1159 priv->ftsp_dev = ent->fts_dev;
1160 priv->ftsp_linksreliable = 0;
1161 for (cpp = ufslike_filesystems; *cpp; cpp++) {
1162 if (strcmp(priv->ftsp_statfs.f_fstypename,
1163 *cpp) == 0) {
1164 priv->ftsp_linksreliable = 1;
1165 break;
1166 }
1167 }
1168 } else {
1169 priv->ftsp_linksreliable = 0;
1170 }
1171 }
1172 return (priv->ftsp_linksreliable);
1173}
|