1N/A/***********************************************************************
1N/A* *
1N/A* This software is part of the ast package *
1N/A* Copyright (c) 1985-2011 AT&T Intellectual Property *
1N/A* and is licensed under the *
1N/A* Common Public License, Version 1.0 *
1N/A* by AT&T Intellectual Property *
1N/A* *
1N/A* A copy of the License is available at *
1N/A* http://www.opensource.org/licenses/cpl1.0.txt *
1N/A* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
1N/A* *
1N/A* Information and Software Systems Research *
1N/A* AT&T Research *
1N/A* Florham Park NJ *
1N/A* *
1N/A* Glenn Fowler <gsf@research.att.com> *
1N/A* David Korn <dgk@research.att.com> *
1N/A* Phong Vo <kpv@research.att.com> *
1N/A* *
1N/A***********************************************************************/
1N/A#pragma prototyped
1N/A/*
1N/A * Phong Vo
1N/A * Glenn Fowler
1N/A * AT&T Research
1N/A *
1N/A * fts implementation unwound from the kpv ftwalk() of 1988-10-30
1N/A */
1N/A
1N/A#include <ast.h>
1N/A#include <ast_dir.h>
1N/A#include <error.h>
1N/A#include <fs3d.h>
1N/A#include <ls.h>
1N/A
1N/Astruct Ftsent;
1N/A
1N/Atypedef int (*Compar_f)(struct Ftsent* const*, struct Ftsent* const*);
1N/Atypedef int (*Stat_f)(const char*, struct stat*);
1N/A
1N/A#define _fts_status status
1N/A#define _fts_statb statb
1N/A
1N/A#define _FTS_PRIVATE_ \
1N/A FTSENT* parent; /* top parent */ \
1N/A FTSENT* todo; /* todo list */ \
1N/A FTSENT* top; /* top element */ \
1N/A FTSENT* root; \
1N/A FTSENT* bot; /* bottom element */ \
1N/A FTSENT* free; /* free element */ \
1N/A FTSENT* diroot; \
1N/A FTSENT* curdir; \
1N/A FTSENT* current; /* current element */ \
1N/A FTSENT* previous; /* previous current */ \
1N/A FTSENT* dotdot; \
1N/A FTSENT* link; /* real current fts_link*/ \
1N/A FTSENT* pwd; /* pwd parent */ \
1N/A DIR* dir; /* current dir stream */ \
1N/A Compar_f comparf; /* node comparison func */ \
1N/A size_t baselen; /* current strlen(base) */ \
1N/A size_t homesize; /* sizeof(home) */ \
1N/A int cd; /* chdir status */ \
1N/A int cpname; \
1N/A int flags; /* fts_open() flags */ \
1N/A int nd; \
1N/A unsigned char children; \
1N/A unsigned char fs3d; \
1N/A unsigned char nostat; \
1N/A unsigned char state; /* fts_read() state */ \
1N/A char* base; /* basename in path */ \
1N/A char* name; \
1N/A char* path; /* path workspace */ \
1N/A char* home; /* home/path buffer */ \
1N/A char* endbase; /* space to build paths */ \
1N/A char* endbuf; /* space to build paths */ \
1N/A char* pad[2]; /* $0.02 to splain this */
1N/A
1N/A/*
1N/A * NOTE: <ftwalk.h> relies on status and statb being the first two elements
1N/A */
1N/A
1N/A#define _FTSENT_PRIVATE_ \
1N/A int nd; /* popdir() count */ \
1N/A FTSENT* left; /* left child */ \
1N/A FTSENT* right; /* right child */ \
1N/A FTSENT* pwd; /* pwd parent */ \
1N/A FTSENT* stack; /* getlist() stack */ \
1N/A long nlink; /* FTS_D link count */ \
1N/A unsigned char must; /* must stat */ \
1N/A unsigned char type; /* DT_* type */ \
1N/A unsigned char symlink; /* originally a symlink */ \
1N/A char name[sizeof(int)]; /* fts_name data */
1N/A
1N/A#include <fts.h>
1N/A
1N/A#ifndef ENOSYS
1N/A#define ENOSYS EINVAL
1N/A#endif
1N/A
1N/A
1N/A#if MAXNAMLEN > 16
1N/A#define MINNAME 32
1N/A#else
1N/A#define MINNAME 16
1N/A#endif
1N/A
1N/A#define drop(p,f) (((f)->fts_namelen < MINNAME) ? ((f)->fts_link = (p)->free, (p)->free = (f)) : (free(f), (p)->free))
1N/A
1N/A#define ACCESS(p,f) ((p)->cd==0?(f)->fts_name:(f)->fts_path)
1N/A#define PATH(f,p,l) ((!((f)->flags&FTS_SEEDOTDIR)&&(l)>0&&(p)[0]=='.'&&(p)[1]=='/')?((p)+2):(p))
1N/A#define SAME(one,two) ((one)->st_ino==(two)->st_ino&&(one)->st_dev==(two)->st_dev)
1N/A#define SKIPLINK(p,f) ((f)->fts_parent->nlink == 0)
1N/A
1N/A#ifdef D_TYPE
1N/A#define ISTYPE(f,t) ((f)->type == (t))
1N/A#define TYPE(f,t) ((f)->type = (t))
1N/A#define SKIP(p,f) ((f)->fts_parent->must == 0 && (((f)->type == DT_UNKNOWN) ? SKIPLINK(p,f) : ((f)->type != DT_DIR && ((f)->type != DT_LNK || ((p)->flags & FTS_PHYSICAL)))))
1N/A#else
1N/A#undef DT_UNKNOWN
1N/A#define DT_UNKNOWN 0
1N/A#undef DT_LNK
1N/A#define DT_LNK 1
1N/A#define ISTYPE(f,t) ((t)==DT_UNKNOWN)
1N/A#define TYPE(f,d)
1N/A#define SKIP(p,f) ((f)->fts_parent->must == 0 && SKIPLINK(p,f))
1N/A#endif
1N/A
1N/A#ifndef D_FILENO
1N/A#define D_FILENO(d) (1)
1N/A#endif
1N/A
1N/A/*
1N/A * NOTE: a malicious dir rename() could change .. underfoot so we
1N/A * must always verify; undef verify to enable the unsafe code
1N/A */
1N/A
1N/A#define verify 1
1N/A
1N/A/*
1N/A * FTS_NOSTAT requires a dir with
1N/A * D_TYPE(&dirent_t)!=DT_UNKNOWN
1N/A * OR
1N/A * st_nlink>=2
1N/A */
1N/A
1N/A#define FTS_children_resume 1
1N/A#define FTS_children_return 2
1N/A#define FTS_error 3
1N/A#define FTS_popstack 4
1N/A#define FTS_popstack_resume 5
1N/A#define FTS_popstack_return 6
1N/A#define FTS_preorder 7
1N/A#define FTS_preorder_resume 8
1N/A#define FTS_preorder_return 9
1N/A#define FTS_readdir 10
1N/A#define FTS_terminal 11
1N/A#define FTS_todo 12
1N/A#define FTS_top_return 13
1N/A
1N/Atypedef int (*Notify_f)(FTS*, FTSENT*, void*);
1N/A
1N/Atypedef struct Notify_s
1N/A{
1N/A struct Notify_s* next;
1N/A Notify_f notifyf;
1N/A void* context;
1N/A} Notify_t;
1N/A
1N/Astatic Notify_t* notify;
1N/A
1N/A/*
1N/A * allocate an FTSENT node
1N/A */
1N/A
1N/Astatic FTSENT*
1N/Anode(FTS* fts, FTSENT* parent, register char* name, register size_t namelen)
1N/A{
1N/A register FTSENT* f;
1N/A register size_t n;
1N/A
1N/A if (fts->free && namelen < MINNAME)
1N/A {
1N/A f = fts->free;
1N/A fts->free = f->fts_link;
1N/A }
1N/A else
1N/A {
1N/A n = (namelen < MINNAME ? MINNAME : namelen + 1) - sizeof(int);
1N/A if (!(f = newof(0, FTSENT, 1, n)))
1N/A {
1N/A fts->fts_errno = errno;
1N/A fts->state = FTS_error;
1N/A return 0;
1N/A }
1N/A f->fts = fts;
1N/A }
1N/A TYPE(f, DT_UNKNOWN);
1N/A f->status = 0;
1N/A f->symlink = 0;
1N/A f->fts_level = (f->fts_parent = parent)->fts_level + 1;
1N/A#if __OBSOLETE__ < 20140101
1N/A f->_fts_level = (short)f->fts_level;
1N/A#endif
1N/A f->fts_link = 0;
1N/A f->fts_pointer = 0;
1N/A f->fts_number = 0;
1N/A f->fts_errno = 0;
1N/A f->fts_namelen = namelen;
1N/A#if __OBSOLETE__ < 20140101
1N/A f->_fts_namelen = (unsigned short)f->fts_namelen;
1N/A#endif
1N/A f->fts_name = f->name;
1N/A f->fts_statp = &f->statb;
1N/A memcpy(f->fts_name, name, namelen + 1);
1N/A return f;
1N/A}
1N/A
1N/A/*
1N/A * compare directories by device/inode
1N/A */
1N/A
1N/Astatic int
1N/Astatcmp(FTSENT* const* pf1, FTSENT* const* pf2)
1N/A{
1N/A register const FTSENT* f1 = *pf1;
1N/A register const FTSENT* f2 = *pf2;
1N/A
1N/A if (f1->statb.st_ino < f2->statb.st_ino)
1N/A return -1;
1N/A if (f1->statb.st_ino > f2->statb.st_ino)
1N/A return 1;
1N/A if (f1->statb.st_dev < f2->statb.st_dev)
1N/A return -1;
1N/A if (f1->statb.st_dev > f2->statb.st_dev)
1N/A return 1;
1N/A
1N/A /*
1N/A * hack for NFS where <dev,ino> may not uniquely identify objects
1N/A */
1N/A
1N/A if (f1->statb.st_mtime < f2->statb.st_mtime)
1N/A return -1;
1N/A if (f1->statb.st_mtime > f2->statb.st_mtime)
1N/A return 1;
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A * search trees with top-down splaying (a la Tarjan and Sleator)
1N/A * when used for insertion sort, this implements a stable sort
1N/A */
1N/A
1N/A#define RROTATE(r) (t = r->left, r->left = t->right, t->right = r, r = t)
1N/A#define LROTATE(r) (t = r->right, r->right = t->left, t->left = r, r = t)
1N/A
1N/Astatic FTSENT*
1N/Asearch(FTSENT* e, FTSENT* root, int(*comparf)(FTSENT* const*, FTSENT* const*), int insert)
1N/A{
1N/A register int cmp;
1N/A register FTSENT* t;
1N/A register FTSENT* left;
1N/A register FTSENT* right;
1N/A register FTSENT* lroot;
1N/A register FTSENT* rroot;
1N/A
1N/A left = right = lroot = rroot = 0;
1N/A while (root)
1N/A {
1N/A if (!(cmp = (*comparf)(&e, &root)) && !insert)
1N/A break;
1N/A if (cmp < 0)
1N/A {
1N/A /*
1N/A * this is the left zig-zig case
1N/A */
1N/A
1N/A if (root->left && (cmp = (*comparf)(&e, &root->left)) <= 0)
1N/A {
1N/A RROTATE(root);
1N/A if (!cmp && !insert)
1N/A break;
1N/A }
1N/A
1N/A /*
1N/A * stick all things > e to the right tree
1N/A */
1N/A
1N/A if (right)
1N/A right->left = root;
1N/A else
1N/A rroot = root;
1N/A right = root;
1N/A root = root->left;
1N/A right->left = 0;
1N/A }
1N/A else
1N/A {
1N/A /*
1N/A * this is the right zig-zig case
1N/A */
1N/A
1N/A if (root->right && (cmp = (*comparf)(&e, &root->right)) >= 0)
1N/A {
1N/A LROTATE(root);
1N/A if (!cmp && !insert)
1N/A break;
1N/A }
1N/A
1N/A /*
1N/A * stick all things <= e to the left tree
1N/A */
1N/A
1N/A if (left)
1N/A left->right = root;
1N/A else
1N/A lroot = root;
1N/A left = root;
1N/A root = root->right;
1N/A left->right = 0;
1N/A }
1N/A }
1N/A if (!root)
1N/A root = e;
1N/A else
1N/A {
1N/A if (right)
1N/A right->left = root->right;
1N/A else
1N/A rroot = root->right;
1N/A if (left)
1N/A left->right = root->left;
1N/A else
1N/A lroot = root->left;
1N/A }
1N/A root->left = lroot;
1N/A root->right = rroot;
1N/A return root;
1N/A}
1N/A
1N/A/*
1N/A * delete the root element from the tree
1N/A */
1N/A
1N/Astatic FTSENT*
1N/Adeleteroot(register FTSENT* root)
1N/A{
1N/A register FTSENT* t;
1N/A register FTSENT* left;
1N/A register FTSENT* right;
1N/A
1N/A right = root->right;
1N/A if (!(left = root->left))
1N/A root = right;
1N/A else
1N/A {
1N/A while (left->right)
1N/A LROTATE(left);
1N/A left->right = right;
1N/A root = left;
1N/A }
1N/A return root;
1N/A}
1N/A
1N/A/*
1N/A * generate ordered fts_link list from binary tree at root
1N/A * FTSENT.stack instead of recursion to avoid blowing the real
1N/A * stack on big directories
1N/A */
1N/A
1N/Astatic void
1N/Agetlist(register FTSENT** top, register FTSENT** bot, register FTSENT* root)
1N/A{
1N/A register FTSENT* stack = 0;
1N/A
1N/A for (;;)
1N/A {
1N/A if (root->left)
1N/A {
1N/A root->stack = stack;
1N/A stack = root;
1N/A root = root->left;
1N/A }
1N/A else
1N/A {
1N/A for (;;)
1N/A {
1N/A if (*top)
1N/A *bot = (*bot)->fts_link = root;
1N/A else
1N/A *bot = *top = root;
1N/A if (root->right)
1N/A {
1N/A root = root->right;
1N/A break;
1N/A }
1N/A if (!(root = stack))
1N/A {
1N/A (*bot)->fts_link = 0;
1N/A return;
1N/A }
1N/A stack = stack->stack;
1N/A }
1N/A }
1N/A }
1N/A}
1N/A
1N/A/*
1N/A * set directory when curdir is lost in space
1N/A */
1N/A
1N/Astatic int
1N/Asetdir(register char* home, register char* path)
1N/A{
1N/A register int cdrv;
1N/A
1N/A if (path[0] == '/')
1N/A cdrv = pathcd(path, NiL);
1N/A else
1N/A {
1N/A /*
1N/A * note that path and home are in the same buffer
1N/A */
1N/A
1N/A path[-1] = '/';
1N/A cdrv = pathcd(home, NiL);
1N/A path[-1] = 0;
1N/A }
1N/A if (cdrv < 0)
1N/A pathcd(home, NiL);
1N/A return cdrv;
1N/A}
1N/A
1N/A/*
1N/A * set to parent dir
1N/A */
1N/A
1N/Astatic int
1N/Asetpdir(register char* home, register char* path, register char* base)
1N/A{
1N/A register int c;
1N/A register int cdrv;
1N/A
1N/A if (base > path)
1N/A {
1N/A c = base[0];
1N/A base[0] = 0;
1N/A cdrv = setdir(home, path);
1N/A base[0] = c;
1N/A }
1N/A else
1N/A cdrv = pathcd(home, NiL);
1N/A return cdrv;
1N/A}
1N/A
1N/A/*
1N/A * pop a set of directories
1N/A */
1N/Astatic int
1N/Apopdirs(FTS* fts)
1N/A{
1N/A register FTSENT*f;
1N/A register char* s;
1N/A register char* e;
1N/A#ifndef verify
1N/A register int verify;
1N/A#endif
1N/A struct stat sb;
1N/A char buf[PATH_MAX];
1N/A
1N/A if (!(f = fts->curdir) || f->fts_level < 0)
1N/A return -1;
1N/A e = buf + sizeof(buf) - 4;
1N/A#ifndef verify
1N/A verify = 0;
1N/A#endif
1N/A while (fts->nd > 0)
1N/A {
1N/A for (s = buf; s < e && fts->nd > 0; fts->nd--)
1N/A {
1N/A if (fts->pwd)
1N/A {
1N/A#ifndef verify
1N/A verify |= fts->pwd->symlink;
1N/A#endif
1N/A fts->pwd = fts->pwd->pwd;
1N/A }
1N/A *s++ = '.';
1N/A *s++ = '.';
1N/A *s++ = '/';
1N/A }
1N/A *s = 0;
1N/A if (chdir(buf))
1N/A return -1;
1N/A }
1N/A return (verify && (stat(".", &sb) < 0 || !SAME(&sb, f->fts_statp))) ? -1 : 0;
1N/A}
1N/A
1N/A/*
1N/A * initialize st from path and fts_info from st
1N/A */
1N/A
1N/Astatic int
1N/Ainfo(FTS* fts, register FTSENT* f, const char* path, struct stat* sp, int flags)
1N/A{
1N/A if (path)
1N/A {
1N/A#ifdef S_ISLNK
1N/A if (!f->symlink && (ISTYPE(f, DT_UNKNOWN) || ISTYPE(f, DT_LNK)))
1N/A {
1N/A if (lstat(path, sp) < 0)
1N/A goto bad;
1N/A }
1N/A else
1N/A#endif
1N/A if (stat(path, sp) < 0)
1N/A goto bad;
1N/A }
1N/A#ifdef S_ISLNK
1N/A again:
1N/A#endif
1N/A if (S_ISDIR(sp->st_mode))
1N/A {
1N/A if ((flags & FTS_NOSTAT) && !fts->fs3d)
1N/A {
1N/A f->fts_parent->nlink--;
1N/A#ifdef D_TYPE
1N/A if ((f->nlink = sp->st_nlink) < 2)
1N/A {
1N/A f->must = 2;
1N/A f->nlink = 2;
1N/A }
1N/A else
1N/A f->must = 0;
1N/A#else
1N/A if ((f->nlink = sp->st_nlink) >= 2)
1N/A f->must = 1;
1N/A else
1N/A f->must = 2;
1N/A#endif
1N/A }
1N/A else
1N/A f->must = 2;
1N/A TYPE(f, DT_DIR);
1N/A f->fts_info = FTS_D;
1N/A }
1N/A#ifdef S_ISLNK
1N/A else if (S_ISLNK((sp)->st_mode))
1N/A {
1N/A struct stat sb;
1N/A
1N/A f->symlink = 1;
1N/A if (!(flags & FTS_PHYSICAL) && stat(path, &sb) >= 0)
1N/A {
1N/A *sp = sb;
1N/A flags = FTS_PHYSICAL;
1N/A goto again;
1N/A }
1N/A TYPE(f, DT_LNK);
1N/A f->fts_info = FTS_SL;
1N/A }
1N/A#endif
1N/A else
1N/A {
1N/A TYPE(f, DT_REG);
1N/A f->fts_info = FTS_F;
1N/A }
1N/A return 0;
1N/A bad:
1N/A TYPE(f, DT_UNKNOWN);
1N/A f->fts_info = FTS_NS;
1N/A return -1;
1N/A}
1N/A
1N/A/*
1N/A * get top list of elements to process
1N/A * ordering delayed until first fts_read()
1N/A * to give caller a chance to set fts->handle
1N/A */
1N/A
1N/Astatic FTSENT*
1N/Atoplist(FTS* fts, register char* const* pathnames)
1N/A{
1N/A register char* path;
1N/A register FTSENT* f;
1N/A register FTSENT* top;
1N/A register FTSENT* bot;
1N/A int physical;
1N/A int metaphysical;
1N/A char* s;
1N/A struct stat st;
1N/A
1N/A if (fts->flags & FTS_NOSEEDOTDIR)
1N/A fts->flags &= ~FTS_SEEDOTDIR;
1N/A physical = (fts->flags & FTS_PHYSICAL);
1N/A metaphysical = (fts->flags & (FTS_META|FTS_PHYSICAL)) == (FTS_META|FTS_PHYSICAL);
1N/A top = bot = 0;
1N/A while (path = *pathnames++)
1N/A {
1N/A /*
1N/A * make elements
1N/A */
1N/A
1N/A if (!(f = node(fts, fts->parent, path, strlen(path))))
1N/A break;
1N/A path = f->fts_name;
1N/A if (!physical)
1N/A f->fts_namelen = (fts->flags & FTS_SEEDOTDIR) ? strlen(path) : (pathcanon(path, strlen(path) + 1, 0) - path);
1N/A else if (*path != '.')
1N/A {
1N/A f->fts_namelen = strlen(path);
1N/A fts->flags |= FTS_SEEDOTDIR;
1N/A }
1N/A else
1N/A {
1N/A if (fts->flags & FTS_NOSEEDOTDIR)
1N/A {
1N/A fts->flags &= ~FTS_SEEDOTDIR;
1N/A s = path;
1N/A while (*s++ == '.' && *s++ == '/')
1N/A {
1N/A while (*s == '/')
1N/A s++;
1N/A if (!*s)
1N/A break;
1N/A path = f->fts_name;
1N/A while (*path++ = *s++);
1N/A path = f->fts_name;
1N/A }
1N/A }
1N/A else
1N/A fts->flags |= FTS_SEEDOTDIR;
1N/A for (s = path + strlen(path); s > path && *(s - 1) == '/'; s--);
1N/A *s = 0;
1N/A f->fts_namelen = s - path;
1N/A }
1N/A#if __OBSOLETE__ < 20140101
1N/A f->_fts_namelen = (unsigned short)f->fts_namelen;
1N/A#endif
1N/A if (!*path)
1N/A {
1N/A errno = ENOENT;
1N/A f->fts_info = FTS_NS;
1N/A }
1N/A else
1N/A info(fts, f, path, f->fts_statp, fts->flags);
1N/A#ifdef S_ISLNK
1N/A
1N/A /*
1N/A * don't let any standards committee get
1N/A * away with calling your idea a hack
1N/A */
1N/A
1N/A if (metaphysical && f->fts_info == FTS_SL && stat(path, &st) >= 0)
1N/A {
1N/A *f->fts_statp = st;
1N/A info(fts, f, NiL, f->fts_statp, 0);
1N/A }
1N/A#endif
1N/A if (bot)
1N/A {
1N/A bot->fts_link = f;
1N/A bot = f;
1N/A }
1N/A else
1N/A top = bot = f;
1N/A }
1N/A return top;
1N/A}
1N/A
1N/A/*
1N/A * order fts->todo if fts->comparf != 0
1N/A */
1N/A
1N/Astatic void
1N/Aorder(FTS* fts)
1N/A{
1N/A register FTSENT* f;
1N/A register FTSENT* root;
1N/A FTSENT* top;
1N/A FTSENT* bot;
1N/A
1N/A top = bot = root = 0;
1N/A for (f = fts->todo; f; f = f->fts_link)
1N/A root = search(f, root, fts->comparf, 1);
1N/A getlist(&top, &bot, root);
1N/A fts->todo = top;
1N/A}
1N/A
1N/A/*
1N/A * resize the path buffer
1N/A * note that free() is not used because we may need to chdir(fts->home)
1N/A * if there isn't enough space to continue
1N/A */
1N/A
1N/Astatic int
1N/Aresize(register FTS* fts, size_t inc)
1N/A{
1N/A register char* old;
1N/A register char* newp;
1N/A register size_t n_old;
1N/A
1N/A /*
1N/A * add space for "/." used in testing FTS_DNX
1N/A */
1N/A
1N/A n_old = fts->homesize;
1N/A fts->homesize = ((fts->homesize + inc + 4) / PATH_MAX + 1) * PATH_MAX;
1N/A if (!(newp = newof(0, char, fts->homesize, 0)))
1N/A {
1N/A fts->fts_errno = errno;
1N/A fts->state = FTS_error;
1N/A return -1;
1N/A }
1N/A old = fts->home;
1N/A fts->home = newp;
1N/A memcpy(newp, old, n_old);
1N/A if (fts->endbuf)
1N/A fts->endbuf = newp + fts->homesize - 4;
1N/A if (fts->path)
1N/A fts->path = newp + (fts->path - old);
1N/A if (fts->base)
1N/A fts->base = newp + (fts->base - old);
1N/A free(old);
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A * open a new fts stream on pathnames
1N/A */
1N/A
1N/AFTS*
1N/Afts_open(char* const* pathnames, int flags, int (*comparf)(FTSENT* const*, FTSENT* const*))
1N/A{
1N/A register FTS* fts;
1N/A
1N/A if (!(fts = newof(0, FTS, 1, sizeof(FTSENT))))
1N/A return 0;
1N/A fts->flags = flags;
1N/A fts->cd = (flags & FTS_NOCHDIR) ? 1 : -1;
1N/A fts->comparf = comparf;
1N/A fts->fs3d = fs3d(FS3D_TEST);
1N/A
1N/A /*
1N/A * set up the path work buffer
1N/A */
1N/A
1N/A fts->homesize = 2 * PATH_MAX;
1N/A for (;;)
1N/A {
1N/A if (!(fts->home = newof(fts->home, char, fts->homesize, 0)))
1N/A {
1N/A free(fts);
1N/A return 0;
1N/A }
1N/A if (fts->cd > 0 || getcwd(fts->home, fts->homesize))
1N/A break;
1N/A if (errno == ERANGE)
1N/A fts->homesize += PATH_MAX;
1N/A else
1N/A fts->cd = 1;
1N/A }
1N/A fts->endbuf = fts->home + fts->homesize - 4;
1N/A
1N/A /*
1N/A * initialize the tippity-top
1N/A */
1N/A
1N/A fts->parent = (FTSENT*)(fts + 1);
1N/A fts->parent->fts_info = FTS_D;
1N/A memcpy(fts->parent->fts_accpath = fts->parent->fts_path = fts->parent->fts_name = fts->parent->name, ".", 2);
1N/A fts->parent->fts_level = -1;
1N/A#if __OBSOLETE__ < 20140101
1N/A fts->parent->_fts_level = (short)fts->parent->fts_level;
1N/A#endif
1N/A fts->parent->fts_statp = &fts->parent->statb;
1N/A fts->parent->must = 2;
1N/A fts->parent->type = DT_UNKNOWN;
1N/A fts->path = fts->home + strlen(fts->home) + 1;
1N/A
1N/A /*
1N/A * make the list of top elements
1N/A */
1N/A
1N/A if (!pathnames || (flags & FTS_ONEPATH) || !*pathnames)
1N/A {
1N/A char* v[2];
1N/A
1N/A v[0] = pathnames && (flags & FTS_ONEPATH) ? (char*)pathnames : ".";
1N/A v[1] = 0;
1N/A fts->todo = toplist(fts, v);
1N/A }
1N/A else
1N/A fts->todo = toplist(fts, pathnames);
1N/A#if _HUH_1997_01_07
1N/A if (!fts->todo || fts->todo->fts_info == FTS_NS && !fts->todo->fts_link)
1N/A#else
1N/A if (!fts->todo)
1N/A#endif
1N/A {
1N/A fts_close(fts);
1N/A return 0;
1N/A }
1N/A return fts;
1N/A}
1N/A
1N/A/*
1N/A * return the next FTS entry
1N/A */
1N/A
1N/AFTSENT*
1N/Afts_read(register FTS* fts)
1N/A{
1N/A register char* s;
1N/A register int n;
1N/A register FTSENT* f;
1N/A struct dirent* d;
1N/A size_t i;
1N/A FTSENT* t;
1N/A Notify_t* p;
1N/A#ifdef verify
1N/A struct stat sb;
1N/A#endif
1N/A
1N/A for (;;)
1N/A switch (fts->state)
1N/A {
1N/A
1N/A case FTS_top_return:
1N/A
1N/A f = fts->todo;
1N/A t = 0;
1N/A while (f)
1N/A if (f->status == FTS_SKIP)
1N/A {
1N/A if (t)
1N/A {
1N/A t->fts_link = f->fts_link;
1N/A drop(fts, f);
1N/A f = t->fts_link;
1N/A }
1N/A else
1N/A {
1N/A fts->todo = f->fts_link;
1N/A drop(fts, f);
1N/A f = fts->todo;
1N/A }
1N/A }
1N/A else
1N/A {
1N/A t = f;
1N/A f = f->fts_link;
1N/A }
1N/A /*FALLTHROUGH*/
1N/A
1N/A case 0:
1N/A
1N/A if (!fts->state && fts->comparf)
1N/A order(fts);
1N/A if (!(f = fts->todo))
1N/A return 0;
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_todo:
1N/A
1N/A /*
1N/A * process the top object on the stack
1N/A */
1N/A
1N/A fts->root = fts->top = fts->bot = 0;
1N/A
1N/A /*
1N/A * initialize the top level
1N/A */
1N/A
1N/A if (f->fts_level == 0)
1N/A {
1N/A fts->parent->fts_number = f->fts_number;
1N/A fts->parent->fts_pointer = f->fts_pointer;
1N/A fts->parent->fts_statp = f->fts_statp;
1N/A fts->parent->statb = *f->fts_statp;
1N/A f->fts_parent = fts->parent;
1N/A fts->diroot = 0;
1N/A if (fts->cd == 0)
1N/A pathcd(fts->home, NiL);
1N/A else if (fts->cd < 0)
1N/A fts->cd = 0;
1N/A fts->pwd = f->fts_parent;
1N/A fts->curdir = fts->cd ? 0 : f->fts_parent;
1N/A *(fts->base = fts->path) = 0;
1N/A }
1N/A
1N/A /*
1N/A * chdir to parent if asked for
1N/A */
1N/A
1N/A if (fts->cd < 0)
1N/A {
1N/A fts->cd = setdir(fts->home, fts->path);
1N/A fts->pwd = f->fts_parent;
1N/A fts->curdir = fts->cd ? 0 : f->fts_parent;
1N/A }
1N/A
1N/A /*
1N/A * add object's name to the path
1N/A */
1N/A
1N/A if ((fts->baselen = f->fts_namelen) >= (fts->endbuf - fts->base) && resize(fts, fts->baselen))
1N/A return 0;
1N/A memcpy(fts->base, f->name, fts->baselen + 1);
1N/A fts->name = fts->cd ? fts->path : fts->base;
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_preorder:
1N/A
1N/A /*
1N/A * check for cycle and open dir
1N/A */
1N/A
1N/A if (f->fts_info == FTS_D)
1N/A {
1N/A if ((fts->diroot = search(f, fts->diroot, statcmp, 0)) != f || f->fts_level > 0 && (t = f) && statcmp(&t, &f->fts_parent) == 0)
1N/A {
1N/A f->fts_info = FTS_DC;
1N/A f->fts_cycle = fts->diroot;
1N/A }
1N/A else if (!(fts->flags & FTS_TOP) && (!(fts->flags & FTS_XDEV) || f->statb.st_dev == f->fts_parent->statb.st_dev))
1N/A {
1N/A /*
1N/A * buffer is known to be large enough here!
1N/A */
1N/A
1N/A if (fts->base[fts->baselen - 1] != '/')
1N/A memcpy(fts->base + fts->baselen, "/.", 3);
1N/A if (!(fts->dir = opendir(fts->name)))
1N/A f->fts_info = FTS_DNX;
1N/A fts->base[fts->baselen] = 0;
1N/A if (!fts->dir && !(fts->dir = opendir(fts->name)))
1N/A f->fts_info = FTS_DNR;
1N/A }
1N/A }
1N/A f->nd = f->fts_info & ~FTS_DNX;
1N/A if (f->nd || !(fts->flags & FTS_NOPREORDER))
1N/A {
1N/A fts->current = f;
1N/A fts->link = f->fts_link;
1N/A f->fts_link = 0;
1N/A f->fts_path = PATH(fts, fts->path, f->fts_level);
1N/A f->fts_pathlen = (fts->base - f->fts_path) + fts->baselen;
1N/A f->fts_accpath = ACCESS(fts, f);
1N/A fts->state = FTS_preorder_return;
1N/A goto note;
1N/A }
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_preorder_resume:
1N/A
1N/A /*
1N/A * prune
1N/A */
1N/A
1N/A if (!fts->dir || f->nd || f->status == FTS_SKIP)
1N/A {
1N/A if (fts->dir)
1N/A {
1N/A closedir(fts->dir);
1N/A fts->dir = 0;
1N/A }
1N/A fts->state = FTS_popstack;
1N/A continue;
1N/A }
1N/A
1N/A /*
1N/A * FTS_D or FTS_DNX, about to read children
1N/A */
1N/A
1N/A if (fts->cd == 0)
1N/A {
1N/A if ((fts->cd = chdir(fts->name)) < 0)
1N/A pathcd(fts->home, NiL);
1N/A else if (fts->pwd != f)
1N/A {
1N/A f->pwd = fts->pwd;
1N/A fts->pwd = f;
1N/A }
1N/A fts->curdir = fts->cd < 0 ? 0 : f;
1N/A }
1N/A fts->nostat = fts->children > 1 || f->fts_info == FTS_DNX;
1N/A fts->cpname = fts->cd && !fts->nostat || !fts->children && !fts->comparf;
1N/A fts->dotdot = 0;
1N/A fts->endbase = fts->base + fts->baselen;
1N/A if (fts->endbase[-1] != '/')
1N/A *fts->endbase++ = '/';
1N/A fts->current = f;
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_readdir:
1N/A
1N/A while (d = readdir(fts->dir))
1N/A {
1N/A s = d->d_name;
1N/A if (s[0] == '.')
1N/A {
1N/A if (s[1] == 0)
1N/A {
1N/A fts->current->nlink--;
1N/A if (!(fts->flags & FTS_SEEDOT))
1N/A continue;
1N/A n = 1;
1N/A }
1N/A else if (s[1] == '.' && s[2] == 0)
1N/A {
1N/A fts->current->nlink--;
1N/A if (fts->current->must == 1)
1N/A fts->current->must = 0;
1N/A if (!(fts->flags & FTS_SEEDOT))
1N/A continue;
1N/A n = 2;
1N/A }
1N/A else
1N/A n = 0;
1N/A }
1N/A else
1N/A n = 0;
1N/A
1N/A /*
1N/A * make a new entry
1N/A */
1N/A
1N/A i = D_NAMLEN(d);
1N/A if (!(f = node(fts, fts->current, s, i)))
1N/A return 0;
1N/A TYPE(f, D_TYPE(d));
1N/A
1N/A /*
1N/A * check for space
1N/A */
1N/A
1N/A if (i >= fts->endbuf - fts->endbase)
1N/A {
1N/A if (resize(fts, i))
1N/A return 0;
1N/A fts->endbase = fts->base + fts->baselen;
1N/A if (fts->endbase[-1] != '/')
1N/A fts->endbase++;
1N/A }
1N/A if (fts->cpname)
1N/A {
1N/A memcpy(fts->endbase, s, i + 1);
1N/A if (fts->cd)
1N/A s = fts->path;
1N/A }
1N/A if (n)
1N/A {
1N/A /*
1N/A * don't recurse on . and ..
1N/A */
1N/A
1N/A if (n == 1)
1N/A f->fts_statp = fts->current->fts_statp;
1N/A else
1N/A {
1N/A if (f->fts_info != FTS_NS)
1N/A fts->dotdot = f;
1N/A if (fts->current->fts_parent->fts_level < 0)
1N/A {
1N/A f->fts_statp = &fts->current->fts_parent->statb;
1N/A info(fts, f, s, f->fts_statp, 0);
1N/A }
1N/A else
1N/A f->fts_statp = fts->current->fts_parent->fts_statp;
1N/A }
1N/A f->fts_info = FTS_DOT;
1N/A }
1N/A else if ((fts->nostat || SKIP(fts, f)) && (f->fts_info = FTS_NSOK) || info(fts, f, s, &f->statb, fts->flags))
1N/A f->statb.st_ino = D_FILENO(d);
1N/A if (fts->comparf)
1N/A fts->root = search(f, fts->root, fts->comparf, 1);
1N/A else if (fts->children || f->fts_info == FTS_D || f->fts_info == FTS_SL)
1N/A {
1N/A if (fts->top)
1N/A fts->bot = fts->bot->fts_link = f;
1N/A else
1N/A fts->top = fts->bot = f;
1N/A }
1N/A else
1N/A {
1N/A /*
1N/A * terminal node
1N/A */
1N/A
1N/A f->fts_path = PATH(fts, fts->path, 1);
1N/A f->fts_pathlen = fts->endbase - f->fts_path + f->fts_namelen;
1N/A f->fts_accpath = ACCESS(fts, f);
1N/A fts->previous = fts->current;
1N/A fts->current = f;
1N/A fts->state = FTS_terminal;
1N/A goto note;
1N/A }
1N/A }
1N/A
1N/A /*
1N/A * done with the directory
1N/A */
1N/A
1N/A closedir(fts->dir);
1N/A fts->dir = 0;
1N/A if (fts->root)
1N/A getlist(&fts->top, &fts->bot, fts->root);
1N/A if (fts->children)
1N/A {
1N/A /*
1N/A * try moving back to parent dir
1N/A */
1N/A
1N/A fts->base[fts->baselen] = 0;
1N/A if (fts->cd <= 0)
1N/A {
1N/A f = fts->current->fts_parent;
1N/A if (fts->cd < 0
1N/A || f != fts->curdir
1N/A || !fts->dotdot
1N/A || !SAME(f->fts_statp, fts->dotdot->fts_statp)
1N/A || fts->pwd && fts->pwd->symlink
1N/A || (fts->cd = chdir("..")) < 0
1N/A#ifdef verify
1N/A || stat(".", &sb) < 0
1N/A || !SAME(&sb, fts->dotdot->fts_statp)
1N/A#endif
1N/A )
1N/A fts->cd = setpdir(fts->home, fts->path, fts->base);
1N/A if (fts->pwd)
1N/A fts->pwd = fts->pwd->pwd;
1N/A fts->curdir = fts->cd ? 0 : f;
1N/A }
1N/A f = fts->current;
1N/A fts->link = f->fts_link;
1N/A f->fts_link = fts->top;
1N/A f->fts_path = PATH(fts, fts->path, f->fts_level);
1N/A f->fts_pathlen = (fts->base - f->fts_path) + f->fts_namelen;
1N/A f->fts_accpath = ACCESS(fts, f);
1N/A fts->state = FTS_children_return;
1N/A goto note;
1N/A }
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_children_resume:
1N/A
1N/A fts->base[fts->baselen] = 0;
1N/A if (fts->top)
1N/A {
1N/A fts->bot->fts_link = fts->todo;
1N/A fts->todo = fts->top;
1N/A fts->top = 0;
1N/A }
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_popstack:
1N/A
1N/A /*
1N/A * pop objects completely processed
1N/A */
1N/A
1N/A fts->nd = 0;
1N/A f = fts->current;
1N/A /*FALLTHROUGH*/
1N/A
1N/A case FTS_popstack_resume:
1N/A
1N/A while (fts->todo && f == fts->todo)
1N/A {
1N/A t = f->fts_parent;
1N/A if ((f->fts_info & FTS_DP) == FTS_D)
1N/A {
1N/A /*
1N/A * delete from <dev,ino> tree
1N/A */
1N/A
1N/A if (f != fts->diroot)
1N/A fts->diroot = search(f, fts->diroot, statcmp, 0);
1N/A fts->diroot = deleteroot(fts->diroot);
1N/A if (f == fts->curdir)
1N/A {
1N/A fts->nd++;
1N/A fts->curdir = t;
1N/A }
1N/A
1N/A /*
1N/A * perform post-order processing
1N/A */
1N/A
1N/A if (!(fts->flags & FTS_NOPOSTORDER) &&
1N/A f->status != FTS_SKIP &&
1N/A f->status != FTS_NOPOSTORDER)
1N/A {
1N/A /*
1N/A * move to parent dir
1N/A */
1N/A
1N/A if (fts->nd > 0)
1N/A fts->cd = popdirs(fts);
1N/A if (fts->cd < 0)
1N/A fts->cd = setpdir(fts->home, fts->path, fts->base);
1N/A fts->curdir = fts->cd ? 0 : t;
1N/A f->fts_info = FTS_DP;
1N/A f->fts_path = PATH(fts, fts->path, f->fts_level);
1N/A f->fts_pathlen = (fts->base - f->fts_path) + f->fts_namelen;
1N/A f->fts_accpath = ACCESS(fts, f);
1N/A
1N/A /*
1N/A * re-stat to update nlink/times
1N/A */
1N/A
1N/A stat(f->fts_accpath, f->fts_statp);
1N/A fts->link = f->fts_link;
1N/A f->fts_link = 0;
1N/A fts->state = FTS_popstack_return;
1N/A goto note;
1N/A }
1N/A }
1N/A
1N/A /*
1N/A * reset base
1N/A */
1N/A
1N/A if (fts->base > fts->path + t->fts_namelen)
1N/A fts->base--;
1N/A *fts->base = 0;
1N/A fts->base -= t->fts_namelen;
1N/A
1N/A /*
1N/A * try again or delete from top of stack
1N/A */
1N/A
1N/A if (f->status == FTS_AGAIN)
1N/A {
1N/A f->fts_info = FTS_D;
1N/A f->status = 0;
1N/A }
1N/A else
1N/A {
1N/A fts->todo = fts->todo->fts_link;
1N/A drop(fts, f);
1N/A }
1N/A f = t;
1N/A }
1N/A
1N/A /*
1N/A * reset current directory
1N/A */
1N/A
1N/A if (fts->nd > 0 && popdirs(fts) < 0)
1N/A {
1N/A pathcd(fts->home, NiL);
1N/A fts->curdir = 0;
1N/A fts->cd = -1;
1N/A }
1N/A if (fts->todo)
1N/A {
1N/A if (*fts->base)
1N/A fts->base += f->fts_namelen;
1N/A if (*(fts->base - 1) != '/')
1N/A *fts->base++ = '/';
1N/A *fts->base = 0;
1N/A f = fts->todo;
1N/A fts->state = FTS_todo;
1N/A continue;
1N/A }
1N/A return 0;
1N/A
1N/A case FTS_children_return:
1N/A
1N/A f = fts->current;
1N/A f->fts_link = fts->link;
1N/A
1N/A /*
1N/A * chdir down again
1N/A */
1N/A
1N/A i = f->fts_info != FTS_DNX;
1N/A n = f->status == FTS_SKIP;
1N/A if (!n && fts->cd == 0)
1N/A {
1N/A if ((fts->cd = chdir(fts->base)) < 0)
1N/A pathcd(fts->home, NiL);
1N/A else if (fts->pwd != f)
1N/A {
1N/A f->pwd = fts->pwd;
1N/A fts->pwd = f;
1N/A }
1N/A fts->curdir = fts->cd ? 0 : f;
1N/A }
1N/A
1N/A /*
1N/A * prune
1N/A */
1N/A
1N/A if (fts->base[fts->baselen - 1] != '/')
1N/A fts->base[fts->baselen] = '/';
1N/A for (fts->bot = 0, f = fts->top; f; )
1N/A if (n || f->status == FTS_SKIP)
1N/A {
1N/A if (fts->bot)
1N/A fts->bot->fts_link = f->fts_link;
1N/A else
1N/A fts->top = f->fts_link;
1N/A drop(fts, f);
1N/A f = fts->bot ? fts->bot->fts_link : fts->top;
1N/A }
1N/A else
1N/A {
1N/A if (fts->children > 1 && i)
1N/A {
1N/A if (f->status == FTS_STAT)
1N/A info(fts, f, NiL, f->fts_statp, 0);
1N/A else if (f->fts_info == FTS_NSOK && !SKIP(fts, f))
1N/A {
1N/A s = f->fts_name;
1N/A if (fts->cd)
1N/A {
1N/A memcpy(fts->endbase, s, f->fts_namelen + 1);
1N/A s = fts->path;
1N/A }
1N/A info(fts, f, s, f->fts_statp, fts->flags);
1N/A }
1N/A }
1N/A fts->bot = f;
1N/A f = f->fts_link;
1N/A }
1N/A fts->children = 0;
1N/A fts->state = FTS_children_resume;
1N/A continue;
1N/A
1N/A case FTS_popstack_return:
1N/A
1N/A f = fts->todo;
1N/A f->fts_link = fts->link;
1N/A f->fts_info = f->status == FTS_AGAIN ? FTS_DP : 0;
1N/A fts->state = FTS_popstack_resume;
1N/A continue;
1N/A
1N/A case FTS_preorder_return:
1N/A
1N/A f = fts->current;
1N/A f->fts_link = fts->link;
1N/A
1N/A /*
1N/A * follow symlink if asked to
1N/A */
1N/A
1N/A if (f->status == FTS_FOLLOW)
1N/A {
1N/A f->status = 0;
1N/A if (f->fts_info == FTS_SL || ISTYPE(f, DT_LNK) || f->fts_info == FTS_NSOK)
1N/A {
1N/A info(fts, f, f->fts_accpath, f->fts_statp, 0);
1N/A if (f->fts_info != FTS_SL)
1N/A {
1N/A fts->state = FTS_preorder;
1N/A continue;
1N/A }
1N/A }
1N/A }
1N/A
1N/A /*
1N/A * about to prune this f and already at home
1N/A */
1N/A
1N/A if (fts->cd == 0 && f->fts_level == 0 && f->nd)
1N/A fts->cd = -1;
1N/A fts->state = FTS_preorder_resume;
1N/A continue;
1N/A
1N/A case FTS_terminal:
1N/A
1N/A f = fts->current;
1N/A if (f->status == FTS_FOLLOW)
1N/A {
1N/A f->status = 0;
1N/A if (f->fts_info == FTS_SL || ISTYPE(f, DT_LNK) || f->fts_info == FTS_NSOK)
1N/A {
1N/A info(fts, f, f->fts_accpath, f->fts_statp, 0);
1N/A if (f->symlink && f->fts_info != FTS_SL)
1N/A {
1N/A if (!(f->fts_link = fts->top))
1N/A fts->bot = f;
1N/A fts->top = f;
1N/A fts->current = fts->previous;
1N/A fts->state = FTS_readdir;
1N/A continue;
1N/A }
1N/A }
1N/A }
1N/A f = f->fts_parent;
1N/A drop(fts, fts->current);
1N/A fts->current = f;
1N/A fts->state = FTS_readdir;
1N/A continue;
1N/A
1N/A case FTS_error:
1N/A
1N/A return 0;
1N/A
1N/A default:
1N/A
1N/A fts->fts_errno = EINVAL;
1N/A fts->state = FTS_error;
1N/A return 0;
1N/A
1N/A }
1N/A note:
1N/A#if __OBSOLETE__ < 20140101
1N/A f->_fts_pathlen = (unsigned short)f->fts_pathlen;
1N/A#endif
1N/A for (p = notify; p; p = p->next)
1N/A if ((n = (*p->notifyf)(fts, f, p->context)) > 0)
1N/A break;
1N/A else if (n < 0)
1N/A {
1N/A fts->fts_errno = EINVAL;
1N/A fts->state = FTS_error;
1N/A return 0;
1N/A }
1N/A return f;
1N/A}
1N/A
1N/A/*
1N/A * set stream or entry flags
1N/A */
1N/A
1N/Aint
1N/Afts_set(register FTS* fts, register FTSENT* f, int status)
1N/A{
1N/A if (fts || !f || f->fts->current != f)
1N/A return -1;
1N/A switch (status)
1N/A {
1N/A case FTS_AGAIN:
1N/A break;
1N/A case FTS_FOLLOW:
1N/A if (!(f->fts_info & FTS_SL))
1N/A return -1;
1N/A break;
1N/A case FTS_NOPOSTORDER:
1N/A break;
1N/A case FTS_SKIP:
1N/A if ((f->fts_info & (FTS_D|FTS_P)) != FTS_D)
1N/A return -1;
1N/A break;
1N/A default:
1N/A return -1;
1N/A }
1N/A f->status = status;
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A * return the list of child entries
1N/A */
1N/A
1N/AFTSENT*
1N/Afts_children(register FTS* fts, int flags)
1N/A{
1N/A register FTSENT* f;
1N/A
1N/A switch (fts->state)
1N/A {
1N/A
1N/A case 0:
1N/A
1N/A if (fts->comparf)
1N/A order(fts);
1N/A fts->state = FTS_top_return;
1N/A return fts->todo;
1N/A
1N/A case FTS_preorder_return:
1N/A
1N/A fts->children = ((flags | fts->flags) & FTS_NOSTAT) ? 2 : 1;
1N/A if (f = fts_read(fts))
1N/A f = f->fts_link;
1N/A return f;
1N/A
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A * return default (FTS_LOGICAL|FTS_META|FTS_PHYSICAL|FTS_SEEDOTDIR) flags
1N/A * conditioned by astconf()
1N/A */
1N/A
1N/Aint
1N/Afts_flags(void)
1N/A{
1N/A register char* s;
1N/A
1N/A s = astconf("PATH_RESOLVE", NiL, NiL);
1N/A if (streq(s, "logical"))
1N/A return FTS_LOGICAL;
1N/A if (streq(s, "physical"))
1N/A return FTS_PHYSICAL|FTS_SEEDOTDIR;
1N/A return FTS_META|FTS_PHYSICAL|FTS_SEEDOTDIR;
1N/A}
1N/A
1N/A/*
1N/A * return 1 if ent is mounted on a local filesystem
1N/A */
1N/A
1N/Aint
1N/Afts_local(FTSENT* ent)
1N/A{
1N/A#ifdef ST_LOCAL
1N/A struct statvfs fs;
1N/A
1N/A return statvfs(ent->fts_path, &fs) || (fs.f_flag & ST_LOCAL);
1N/A#else
1N/A return !strgrpmatch(fmtfs(ent->fts_statp), "([an]fs|samb)", NiL, 0, STR_LEFT|STR_ICASE);
1N/A#endif
1N/A}
1N/A
1N/A/*
1N/A * close an open fts stream
1N/A */
1N/A
1N/Aint
1N/Afts_close(register FTS* fts)
1N/A{
1N/A register FTSENT* f;
1N/A register FTSENT* x;
1N/A
1N/A if (fts->dir)
1N/A closedir(fts->dir);
1N/A if (fts->cd == 0)
1N/A pathcd(fts->home, NiL);
1N/A free(fts->home);
1N/A if (fts->state == FTS_children_return)
1N/A fts->current->fts_link = fts->link;
1N/A if (fts->top)
1N/A {
1N/A fts->bot->fts_link = fts->todo;
1N/A fts->todo = fts->top;
1N/A }
1N/A for (f = fts->todo; f; f = x)
1N/A {
1N/A x = f->fts_link;
1N/A free(f);
1N/A }
1N/A for (f = fts->free; f; f = x)
1N/A {
1N/A x = f->fts_link;
1N/A free(f);
1N/A }
1N/A free(fts);
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A * register function to be called for each fts_read() entry
1N/A * context==0 => unregister notifyf
1N/A */
1N/A
1N/Aint
1N/Afts_notify(Notify_f notifyf, void* context)
1N/A{
1N/A register Notify_t* np;
1N/A register Notify_t* pp;
1N/A
1N/A if (context)
1N/A {
1N/A if (!(np = newof(0, Notify_t, 1, 0)))
1N/A return -1;
1N/A np->notifyf = notifyf;
1N/A np->context = context;
1N/A np->next = notify;
1N/A notify = np;
1N/A }
1N/A else
1N/A {
1N/A for (np = notify, pp = 0; np; pp = np, np = np->next)
1N/A if (np->notifyf == notifyf)
1N/A {
1N/A if (pp)
1N/A pp->next = np->next;
1N/A else
1N/A notify = np->next;
1N/A free(np);
1N/A return 0;
1N/A }
1N/A return -1;
1N/A }
1N/A return 0;
1N/A}