/* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ #include "restore.h" #include #include #include #include /* LINTED: this file really is necessary */ #include #include /* * Insure that all the components of a pathname exist. Note that * lookupname() and addentry() both expect complex names as * input arguments, so a double NULL needs to be added to each name. */ void pathcheck(char *name) { char *cp, save; struct entry *ep; char *start; start = strchr(name, '/'); if (start == 0) return; for (cp = start; *cp != '\0'; cp++) { if (*cp != '/') continue; *cp = '\0'; save = *(cp+1); *(cp+1) = '\0'; ep = lookupname(name); if (ep == NIL) { ep = addentry(name, psearch(name), NODE); newnode(ep); } /* LINTED: result fits in a short */ ep->e_flags |= NEW|KEEP; *cp = '/'; *(cp+1) = save; } } /* * Change a name to a unique temporary name. */ void mktempname(struct entry *ep) { char *newname; if (ep->e_flags & TMPNAME) badentry(ep, gettext("mktempname: called with TMPNAME")); /* LINTED: result fits in a short */ ep->e_flags |= TMPNAME; newname = savename(gentempname(ep)); renameit(myname(ep), newname); freename(ep->e_name); ep->e_name = newname; /* LINTED: savename guarantees strlen will fit */ ep->e_namlen = strlen(ep->e_name); } /* * Generate a temporary name for an entry. */ char * gentempname(struct entry *ep) { static char name[MAXPATHLEN]; struct entry *np; long i = 0; for (np = lookupino(ep->e_ino); np != NIL && np != ep; np = np->e_links) i++; if (np == NIL) badentry(ep, gettext("not on ino list")); (void) snprintf(name, sizeof (name), "%s%ld%lu", TMPHDR, i, ep->e_ino); return (name); } /* * Rename a file or directory. */ void renameit(char *fp, char *tp) { int fromfd, tofd; char *from, *to; char tobuf[MAXPATHLEN]; char *pathend; resolve(fp, &fromfd, &from); /* * The to pointer argument is assumed to be either a fully * specified path (starting with "./") or a simple temporary * file name (starting with TMPHDR). If passed a simple temp * file name, we need to set up the descriptors explicitly. */ if (strncmp(tp, TMPHDR, sizeof (TMPHDR) - 1) == 0) { tofd = fromfd; if ((pathend = strrchr(from, '/')) != NULL) { strncpy(tobuf, from, pathend - from + 1); tobuf[pathend - from + 1] = '\0'; strlcat(tobuf, tp, sizeof (tobuf)); to = tobuf; } else { to = tp; } } else resolve(tp, &tofd, &to); if (renameat(fromfd, from, tofd, to) < 0) { int saverr = errno; (void) fprintf(stderr, gettext("Warning: cannot rename %s to %s: %s\n"), from, to, strerror(saverr)); (void) fflush(stderr); } else { vprintf(stdout, gettext("rename %s to %s\n"), from, to); } if (fromfd != AT_FDCWD) (void) close(fromfd); if (tofd != AT_FDCWD) (void) close(tofd); } /* * Create a new node (directory). Note that, because we have no * mkdirat() function, fchdir() must be used set up the appropriate * name space context prior to the call to mkdir() if we are * operating in attribute space. */ void newnode(struct entry *np) { char *cp; int dfd; if (np->e_type != NODE) badentry(np, gettext("newnode: not a node")); resolve(myname(np), &dfd, &cp); if (dfd != AT_FDCWD) { if (fchdir(dfd) < 0) { int saverr = errno; (void) fprintf(stderr, gettext("Warning: cannot create %s: %s"), cp, strerror(saverr)); (void) fflush(stderr); (void) close(dfd); return; } } if (mkdir(cp, 0777) < 0) { int saverr = errno; /* LINTED: result fits in a short */ np->e_flags |= EXISTED; (void) fprintf(stderr, gettext("Warning: ")); (void) fflush(stderr); (void) fprintf(stderr, "%s: %s\n", cp, strerror(saverr)); } else { vprintf(stdout, gettext("Make node %s\n"), cp); } if (dfd != AT_FDCWD) { fchdir(savepwd); (void) close(dfd); } } /* * Remove an old node (directory). See comment above on newnode() * for explanation of fchdir() use below. */ void removenode(struct entry *ep) { char *cp; int dfd; if (ep->e_type != NODE) badentry(ep, gettext("removenode: not a node")); if (ep->e_entries != NIL) badentry(ep, gettext("removenode: non-empty directory")); /* LINTED: result fits in a short */ ep->e_flags |= REMOVED; /* LINTED: result fits in a short */ ep->e_flags &= ~TMPNAME; resolve(myname(ep), &dfd, &cp); if (dfd != AT_FDCWD) { if (fchdir(dfd) < 0) { int saverr = errno; (void) fprintf(stderr, gettext("Warning: cannot remove %s: %s"), cp, strerror(saverr)); (void) fflush(stderr); (void) close(dfd); return; } } if (rmdir(cp) < 0) { /* NOTE: could use unlinkat (..,REMOVEDIR) */ int saverr = errno; (void) fprintf(stderr, gettext("Warning: %s: %s\n"), cp, strerror(saverr)); (void) fflush(stderr); } else { vprintf(stdout, gettext("Remove node %s\n"), cp); } if (dfd != AT_FDCWD) { (void) fchdir(savepwd); (void) close(dfd); } } /* * Remove a leaf. */ void removeleaf(struct entry *ep) { char *cp; int dfd; if (ep->e_type != LEAF) badentry(ep, gettext("removeleaf: not a leaf")); /* LINTED: result fits in a short */ ep->e_flags |= REMOVED; /* LINTED: result fits in a short */ ep->e_flags &= ~TMPNAME; resolve(myname(ep), &dfd, &cp); if (unlinkat(dfd, cp, 0) < 0) { int saverr = errno; (void) fprintf(stderr, gettext("Warning: %s: %s\n"), cp, strerror(saverr)); (void) fflush(stderr); } else { vprintf(stdout, gettext("Remove leaf %s\n"), cp); } if (dfd != AT_FDCWD) (void) close(dfd); } /* * Create a link. * This function assumes that the context has already been set * for the link file to be created (i.e., we have "fchdir-ed" * into attribute space already if this is an attribute link). */ int lf_linkit(char *existing, char *new, int type) { char linkbuf[MAXPATHLEN]; struct stat64 s1[1], s2[1]; char *name; int dfd, l, result; resolve(existing, &dfd, &name); if (dfd == -1) { (void) fprintf(stderr, gettext( "Warning: cannot restore %s link %s->%s\n"), (type == SYMLINK ? "symbolic" : "hard"), new, existing); result = FAIL; goto out; } if (type == SYMLINK) { if (symlink(name, new) < 0) { /* No trailing \0 from readlink(2) */ if (((l = readlink(new, linkbuf, sizeof (linkbuf))) > 0) && (l == strlen(name)) && (strncmp(linkbuf, name, l) == 0)) { vprintf(stdout, gettext("Symbolic link %s->%s ok\n"), new, name); result = GOOD; goto out; } else { int saverr = errno; (void) fprintf(stderr, gettext( "Warning: cannot create symbolic link %s->%s: %s"), new, name, strerror(saverr)); (void) fflush(stderr); result = FAIL; goto out; } } } else if (type == HARDLINK) { if (link(name, new) < 0) { int saverr = errno; if ((stat64(name, s1) == 0) && (stat64(new, s2) == 0) && (s1->st_dev == s2->st_dev) && (s1->st_ino == s2->st_ino)) { vprintf(stdout, gettext("Hard link %s->%s ok\n"), new, name); result = GOOD; goto out; } else { (void) fprintf(stderr, gettext( "Warning: cannot create hard link %s->%s: %s\n"), new, name, strerror(saverr)); (void) fflush(stderr); result = FAIL; goto out; } } } else { panic(gettext("%s: unknown type %d\n"), "linkit", type); result = FAIL; goto out; } result = GOOD; if (type == SYMLINK) vprintf(stdout, gettext("Create symbolic link %s->%s\n"), new, name); else vprintf(stdout, gettext("Create hard link %s->%s\n"), new, name); out: if (dfd != AT_FDCWD) { (void) close(dfd); } return (result); } /* * Find lowest-numbered inode (above "start") that needs to be extracted. * Caller knows that a return value of maxino means there's nothing left. */ ino_t lowerbnd(ino_t start) { struct entry *ep; for (; start < maxino; start++) { ep = lookupino(start); if (ep == NIL || ep->e_type == NODE) continue; if (ep->e_flags & (NEW|EXTRACT)) return (start); } return (start); } /* * Find highest-numbered inode (below "start") that needs to be extracted. */ ino_t upperbnd(ino_t start) { struct entry *ep; for (; start > ROOTINO; start--) { ep = lookupino(start); if (ep == NIL || ep->e_type == NODE) continue; if (ep->e_flags & (NEW|EXTRACT)) return (start); } return (start); } /* * report on a badly formed entry */ void badentry(struct entry *ep, char *msg) { (void) fprintf(stderr, gettext("bad entry: %s\n"), msg); (void) fprintf(stderr, gettext("name: %s\n"), myname(ep)); (void) fprintf(stderr, gettext("parent name %s\n"), myname(ep->e_parent)); if (ep->e_sibling != NIL) (void) fprintf(stderr, gettext("sibling name: %s\n"), myname(ep->e_sibling)); if (ep->e_entries != NIL) (void) fprintf(stderr, gettext("next entry name: %s\n"), myname(ep->e_entries)); if (ep->e_links != NIL) (void) fprintf(stderr, gettext("next link name: %s\n"), myname(ep->e_links)); if (ep->e_xattrs != NIL) (void) fprintf(stderr, gettext("attribute root name: %s\n"), myname(ep->e_xattrs)); if (ep->e_next != NIL) (void) fprintf(stderr, gettext("next hashchain name: %s\n"), myname(ep->e_next)); (void) fprintf(stderr, gettext("entry type: %s\n"), ep->e_type == NODE ? gettext("NODE") : gettext("LEAF")); (void) fprintf(stderr, gettext("inode number: %lu\n"), ep->e_ino); panic(gettext("flags: %s\n"), flagvalues(ep)); /* Our callers are expected to handle our returning. */ } /* * Construct a string indicating the active flag bits of an entry. */ char * flagvalues(struct entry *ep) { static char flagbuf[BUFSIZ]; (void) strlcpy(flagbuf, gettext("|NIL"), sizeof (flagbuf)); flagbuf[0] = '\0'; if (ep->e_flags & REMOVED) (void) strlcat(flagbuf, gettext("|REMOVED"), sizeof (flagbuf)); if (ep->e_flags & TMPNAME) (void) strlcat(flagbuf, gettext("|TMPNAME"), sizeof (flagbuf)); if (ep->e_flags & EXTRACT) (void) strlcat(flagbuf, gettext("|EXTRACT"), sizeof (flagbuf)); if (ep->e_flags & NEW) (void) strlcat(flagbuf, gettext("|NEW"), sizeof (flagbuf)); if (ep->e_flags & KEEP) (void) strlcat(flagbuf, gettext("|KEEP"), sizeof (flagbuf)); if (ep->e_flags & EXISTED) (void) strlcat(flagbuf, gettext("|EXISTED"), sizeof (flagbuf)); if (ep->e_flags & XATTR) (void) strlcat(flagbuf, gettext("|XATTR"), sizeof (flagbuf)); if (ep->e_flags & XATTRROOT) (void) strlcat(flagbuf, gettext("|XATTRROOT"), sizeof (flagbuf)); return (&flagbuf[1]); } /* * Check to see if a name is on a dump tape. */ ino_t dirlookup(char *name) { ino_t ino; ino = psearch(name); if (ino == 0 || BIT(ino, dumpmap) == 0) (void) fprintf(stderr, gettext("%s is not on volume\n"), name); return (ino); } /* * Elicit a reply. */ int reply(char *question) { char *yesorno = gettext("yn"); /* must be two characters, "yes" first */ int c; do { (void) fprintf(stderr, "%s? [%s] ", question, yesorno); (void) fflush(stderr); c = getc(terminal); while (c != '\n' && getc(terminal) != '\n') { if (ferror(terminal)) { (void) fprintf(stderr, gettext( "Error reading response\n")); (void) fflush(stderr); return (FAIL); } if (feof(terminal)) return (FAIL); } if (isupper(c)) c = tolower(c); } while (c != yesorno[0] && c != yesorno[1]); if (c == yesorno[0]) return (GOOD); return (FAIL); } /* * handle unexpected inconsistencies */ /* * Note that a panic w/ EOF on the tty means all panics will return... */ #include /* VARARGS1 */ void panic(const char *msg, ...) { va_list args; va_start(args, msg); (void) vfprintf(stderr, msg, args); va_end(args); if (reply(gettext("abort")) == GOOD) { if (reply(gettext("dump core")) == GOOD) abort(); done(1); } } /* * Locale-specific version of ctime */ char * lctime(time_t *tp) { static char buf[256]; struct tm *tm; tm = localtime(tp); (void) strftime(buf, sizeof (buf), "%c\n", tm); return (buf); } static int statcmp(const struct stat *left, const struct stat *right) { int result = 1; if ((left->st_dev == right->st_dev) && (left->st_ino == right->st_ino) && (left->st_mode == right->st_mode) && (left->st_nlink == right->st_nlink) && (left->st_uid == right->st_uid) && (left->st_gid == right->st_gid) && (left->st_rdev == right->st_rdev) && (left->st_ctim.tv_sec == right->st_ctim.tv_sec) && (left->st_ctim.tv_nsec == right->st_ctim.tv_nsec) && (left->st_mtim.tv_sec == right->st_mtim.tv_sec) && (left->st_mtim.tv_nsec == right->st_mtim.tv_nsec) && (left->st_blksize == right->st_blksize) && (left->st_blocks == right->st_blocks)) { result = 0; } return (result); } /* * Safely open a file. */ int safe_open(int dfd, const char *filename, int mode, int perms) { static int init_syslog = 1; int fd; int working_mode; int saverr; char *errtext; struct stat pre_stat, pre_lstat; struct stat post_stat, post_lstat; if (init_syslog) { openlog(progname, LOG_CONS, LOG_DAEMON); init_syslog = 0; } /* * Don't want to be spoofed into trashing something we * shouldn't, thus the following rigamarole. If it doesn't * exist, we create it and proceed. Otherwise, require that * what's there be a real file with no extraneous links and * owned by whoever ran us. * * The silliness with using both lstat() and fstat() is to avoid * race-condition games with someone replacing the file with a * symlink after we've opened it. If there was an flstat(), * we wouldn't need the fstat(). * * The initial open with the hard-coded flags is ok even if we * are intending to open only for reading. If it succeeds, * then the file did not exist, and we'll synthesize an appropriate * complaint below. Otherwise, it does exist, so we won't be * truncating it with the open. */ if ((fd = openat(dfd, filename, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL|O_LARGEFILE, perms)) < 0) { if (errno == EEXIST) { if (fstatat(dfd, filename, &pre_lstat, AT_SYMLINK_NOFOLLOW) < 0) { saverr = errno; (void) close(fd); errno = saverr; return (-1); } if (fstatat(dfd, filename, &pre_stat, 0) < 0) { saverr = errno; (void) close(fd); errno = saverr; return (-1); } working_mode = mode & (O_WRONLY|O_RDWR|O_RDONLY); working_mode |= O_LARGEFILE; if ((fd = openat(dfd, filename, working_mode)) < 0) { if (errno == ENOENT) { errtext = gettext( "Unexpected condition detected: %s used to exist, but doesn't any longer\n"); (void) fprintf(stderr, errtext, filename); syslog(LOG_WARNING, errtext, filename); errno = ENOENT; } return (-1); } if (fstatat(fd, NULL, &post_lstat, AT_SYMLINK_NOFOLLOW) < 0) { saverr = errno; (void) close(fd); errno = saverr; return (-1); } if (fstatat(fd, NULL, &post_stat, 0) < 0) { saverr = errno; (void) close(fd); errno = saverr; return (-1); } if (statcmp(&pre_lstat, &post_lstat) != 0) { errtext = gettext( "Unexpected condition detected: %s's lstat(2) information changed\n"); (void) fprintf(stderr, errtext, filename); syslog(LOG_WARNING, errtext, filename); errno = EPERM; return (-1); } if (statcmp(&pre_stat, &post_stat) != 0) { errtext = gettext( "Unexpected condition detected: %s's stat(2) information changed\n"); (void) fprintf(stderr, errtext, filename); syslog(LOG_WARNING, errtext, filename); errno = EPERM; return (-1); } /* * If inode, device, or type are wrong, bail out. */ if ((!S_ISREG(post_lstat.st_mode) || (post_stat.st_ino != post_lstat.st_ino) || (post_stat.st_dev != post_lstat.st_dev))) { errtext = gettext( "Unexpected condition detected: %s is not a regular file\n"); (void) fprintf(stderr, errtext, filename); syslog(LOG_WARNING, errtext, filename); (void) close(fd); errno = EPERM; return (-1); } /* * Bad link count implies someone's linked our * target to something else, which we probably * shouldn't step on. */ if (post_lstat.st_nlink != 1) { errtext = gettext( "Unexpected condition detected: %s must have exactly one link\n"); (void) fprintf(stderr, errtext, filename); syslog(LOG_WARNING, errtext, filename); (void) close(fd); errno = EPERM; return (-1); } /* * Root might make a file, but non-root might * need to open it. If the permissions let us * get this far, then let it through. */ if (post_lstat.st_uid != getuid() && post_lstat.st_uid != 0) { errtext = gettext( "Unsupported condition detected: %s must be owned by uid %ld or 0\n"); (void) fprintf(stderr, errtext, filename, (long)getuid()); syslog(LOG_WARNING, errtext, filename, (long)getuid()); (void) close(fd); errno = EPERM; return (-1); } if (mode & (O_WRONLY|O_TRUNC)) { if (ftruncate(fd, (off_t)0) < 0) { (void) fprintf(stderr, "ftruncate(%s): %s\n", filename, strerror(errno)); (void) close(fd); return (-1); } } } else { /* * Didn't exist, but couldn't open it. */ return (-1); } } else { /* * If truncating open succeeded for a read-only open, * bail out, as we really shouldn't have succeeded. */ if (mode & O_RDONLY) { /* Undo the O_CREAT */ (void) unlinkat(dfd, filename, 0); (void) fprintf(stderr, "open(%s): %s\n", filename, strerror(ENOENT)); (void) close(fd); errno = ENOENT; return (-1); } } return (fd); } /* * STDIO version of safe_open. Equivalent to fopen64(...). */ FILE * safe_fopen(const char *filename, const char *smode, int perms) { int fd; int bmode; /* * accepts only modes "r", "r+", and "w" */ if (smode[0] == 'r') { if (smode[1] == '\0') { bmode = O_RDONLY; } else if ((smode[1] == '+') && (smode[2] == '\0')) { bmode = O_RDWR; } } else if ((smode[0] == 'w') && (smode[1] == '\0')) { bmode = O_WRONLY; } else { (void) fprintf(stderr, gettext("internal error: safe_fopen: invalid mode `%s'\n"), smode); return (NULL); } fd = safe_open(AT_FDCWD, filename, bmode, perms); /* * caller is expected to report error. */ if (fd >= 0) return (fdopen(fd, smode)); return ((FILE *)NULL); } /* * Read the contents of a directory. */ int mkentry(char *name, ino_t ino, struct arglist *ap) { struct afile *fp; if (ap->base == NULL) { ap->nent = 20; ap->base = (struct afile *)calloc((unsigned)ap->nent, sizeof (*(ap->base))); if (ap->base == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), ap->cmd); return (FAIL); } } if (ap->head == NULL) ap->head = ap->last = ap->base; fp = ap->last; fp->fnum = ino; fp->fname = savename(name); fp++; if (fp == ap->head + ap->nent) { ap->base = (struct afile *)realloc((char *)ap->base, (size_t)(2 * ap->nent * (size_t)sizeof (*(ap->base)))); if (ap->base == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), ap->cmd); return (FAIL); } ap->head = ap->base; fp = ap->head + ap->nent; ap->nent *= 2; } ap->last = fp; return (GOOD); } static int gmatch(wchar_t *, wchar_t *); static int addg(struct direct *, char *, char *, struct arglist *); /* * XXX This value is ASCII (but not language) dependent. In * ASCII, it is the DEL character (unlikely to appear in paths). * If you are compiling on an EBCDIC-based machine, re-define * this (0x7f is '"') to be something like 0x7 (DEL). It's * either this hack or re-write the expand() algorithm... */ #define DELIMCHAR ((char)0x7f) /* * Expand a file name. * "as" is the pattern to expand. * "rflg" non-zero indicates that we're recursing. * "ap" is where to put the results of the expansion. * * Our caller guarantees that "as" is at least the string ".". */ int expand(char *as, int rflg, struct arglist *ap) { int count, size; char dir = 0; char *rescan = 0; RST_DIR *dirp; char *s, *cs; int sindex, rindexa, lindex; struct direct *dp; char slash; char *rs; char c; wchar_t w_fname[PATH_MAX+1]; wchar_t w_pname[PATH_MAX+1]; /* * check for meta chars */ s = cs = as; slash = 0; while (*cs != '*' && *cs != '?' && *cs != '[') { if (*cs++ == 0) { if (rflg && slash) break; else return (0); } else if (*cs == '/') { slash++; } } for (;;) { if (cs == s) { s = ""; break; } else if (*--cs == '/') { *cs = 0; if (s == cs) s = "/"; break; } } if ((dirp = rst_opendir(s)) != NULL) dir++; count = 0; if (*cs == 0) *cs++ = DELIMCHAR; if (dir) { /* * check for rescan */ rs = cs; do { if (*rs == '/') { rescan = rs; *rs = 0; } } while (*rs++); /* LINTED: result fits into an int */ sindex = (int)(ap->last - ap->head); (void) mbstowcs(w_pname, cs, PATH_MAX); w_pname[PATH_MAX - 1] = 0; while ((dp = rst_readdir(dirp)) != NULL && dp->d_ino != 0) { if (!dflag && BIT(dp->d_ino, dumpmap) == 0) continue; if ((*dp->d_name == '.' && *cs != '.')) continue; (void) mbstowcs(w_fname, dp->d_name, PATH_MAX); w_fname[PATH_MAX - 1] = 0; if (gmatch(w_fname, w_pname)) { if (addg(dp, s, rescan, ap) < 0) { rst_closedir(dirp); return (-1); } count++; } } if (rescan) { rindexa = sindex; /* LINTED: result fits into an int */ lindex = (int)(ap->last - ap->head); if (count) { count = 0; while (rindexa < lindex) { size = expand(ap->head[rindexa].fname, 1, ap); if (size < 0) { rst_closedir(dirp); return (size); } count += size; rindexa++; } } /* LINTED: lint is confused about pointer size/type */ bcopy((void *)(&ap->head[lindex]), (void *)(&ap->head[sindex]), (size_t)((ap->last - &ap->head[rindexa])) * sizeof (*ap->head)); ap->last -= lindex - sindex; *rescan = '/'; } rst_closedir(dirp); } s = as; while ((c = *s) != '\0') *s++ = (c != DELIMCHAR ? c : '/'); return (count); } /* * Check for a name match */ static int gmatch(wchar_t *s, wchar_t *p) { long scc; /* source character to text */ wchar_t c; /* pattern character to match */ char ok; /* [x-y] range match status */ long lc; /* left character of [x-y] range */ scc = *s++; switch (c = *p++) { case '[': ok = 0; lc = -1; while (c = *p++) { if (c == ']') { return (ok ? gmatch(s, p) : 0); } else if (c == '-') { wchar_t rc = *p++; /* * Check both ends must belong to * the same codeset. */ if (wcsetno(lc) != wcsetno(rc)) { /* * If not, ignore the '-' * operator and [x-y] is * treated as if it were * [xy]. */ if (scc == lc) ok++; if (scc == (lc = rc)) ok++; } else if (lc <= scc && scc <= rc) ok++; } else { lc = c; if (scc == lc) ok++; } } /* No closing bracket => failure */ return (0); default: if (c != scc) return (0); /*FALLTHROUGH*/ case '?': return (scc ? gmatch(s, p) : 0); case '*': if (*p == 0) return (1); s--; while (*s) { if (gmatch(s++, p)) return (1); } return (0); case 0: return (scc == 0); } } /* * Construct a matched name. */ static int addg(struct direct *dp, char *as1, char *as3, struct arglist *ap) { char *s1, *s2, *limit; int c; char buf[MAXPATHLEN + 1]; s2 = buf; limit = buf + sizeof (buf) - 1; s1 = as1; while ((c = *s1++) != '\0' && s2 < limit) { if (c == DELIMCHAR) { *s2++ = '/'; break; } /* LINTED narrowing cast */ *s2++ = (char)c; } s1 = dp->d_name; while ((*s2 = *s1++) != '\0' && s2 < limit) s2++; s1 = as3; if (s1 != NULL && s2 < limit) { *s2++ = '/'; while ((*s2++ = *++s1) != '\0' && s2 < limit) { continue; /*LINTED [empty loop body]*/ } } *s2 = '\0'; if (mkentry(buf, dp->d_ino, ap) == FAIL) return (-1); return (0); } /* * Resolve a "complex" pathname (as generated by myname()) into * a file descriptor and a relative path. The file descriptor * will reference the hidden directory containing the attribute * named by the relative path. If the provided path is not * complex, the returned file descriptor will be AT_FDCWD and rpath * will equal path. * * This function is intended to be used to transform a complex * pathname into a pair of handles that can be used to actually * manipulate the named file. Since extended attributes have * an independant name space, a file descriptor for a directory * in the attribute name space is necessary to actually manipulate * the attribute file (via the path-relative xxxat() system calls * or a call to fchdir()). * * In the event of an error, the returned file descriptor will be * -1. It is expected that callers will either check for this * condition directly, or attempt to use the descriptor, fail, and * generate an appropriate context-specific error message. * * This function is pretty much a no-op for "simple" (non-attribute) * paths. */ void resolve(char *path, int *fd, char **rpath) { int tfd; *fd = tfd = AT_FDCWD; *rpath = path; path = *rpath + strlen(*rpath) +1; while (*path != '\0' && (*fd = openat64(tfd, *rpath, O_RDONLY)) > 0) { if (tfd != AT_FDCWD) (void) close(tfd); tfd = *fd; *rpath = path; path = *rpath + strlen(*rpath) +1; } if (*fd == AT_FDCWD) return; if (*fd < 0 || (*fd = openat64(tfd, ".", O_RDONLY|O_XATTR)) < 0) { int saverr = errno; (void) fprintf(stderr, gettext("Warning: cannot fully resolve %s: %s"), path, strerror(saverr)); (void) fflush(stderr); } if (tfd != AT_FDCWD) (void) close(tfd); } /* * Copy a complex pathname to another string. Note that the * length returned by this function is the number of characters * up to (but not including) the final NULL. */ int complexcpy(char *s1, char *s2, int max) { int nullseen = 0; int len = 0; while (len++ < max) { *s1++ = *s2; if (*s2++ == '\0') { if (nullseen) return (len-1); else nullseen = 1; } else { nullseen = 0; } } *s1 = '\0'; if (nullseen == 0) *--s1 = '\0'; fprintf(stderr, gettext("Warning: unterminated source string in complexcpy\n")); return (max-1); }