1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
24 * Copyright (c) 2013 Andrew Stormont. All rights reserved.
25 */
26
27
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30
31
32 /* Parts of this product may be derived from */
33 /* Mortice Kern Systems Inc. and Berkeley 4.3 BSD systems. */
34 /* licensed from Mortice Kern Systems Inc. and */
35 /* the University of California. */
36
37 /*
38 * Copyright 1985, 1990 by Mortice Kern Systems Inc. All rights reserved.
39 */
40
41 #include <stdio.h>
42 #include <errno.h>
43 #include <pwd.h>
44 #include <grp.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/param.h>
48 #include <sys/acl.h>
49 #include <limits.h>
50 #include <unistd.h>
51 #include <stdlib.h>
52 #include <locale.h>
53 #include <string.h>
54 #include <strings.h>
55 #include <ctype.h>
56 #include <wait.h>
57 #include <fnmatch.h>
58 #include <langinfo.h>
59 #include <ftw.h>
60 #include <libgen.h>
61 #include <err.h>
62 #include <regex.h>
63 #include "getresponse.h"
64
65 #define A_DAY (long)(60*60*24) /* a day full of seconds */
66 #define A_MIN (long)(60)
67 #define BLKSIZ 512
68 #define round(x, s) (((x)+(s)-1)&~((s)-1))
69 #ifndef FTW_SLN
70 #define FTW_SLN 7
71 #endif
72 #define LINEBUF_SIZE LINE_MAX /* input or output lines */
73 #define REMOTE_FS "/etc/dfs/fstypes"
74 #define N_FSTYPES 20
75 #define SHELL_MAXARGS 253 /* see doexec() for description */
76
77 /*
78 * This is the list of operations
79 * F_USER and F_GROUP are named to avoid conflict with USER and GROUP defined
80 * in sys/acl.h
81 */
82
83 enum Command
84 {
85 PRINT,
86 ACL, AMIN, AND, ATIME, CMIN, CPIO, CSIZE, CTIME, DEPTH, EXEC, F_GROUP,
87 F_GROUPACL, F_USER, F_USERACL, FOLLOW, FSTYPE, INAME, INUM, IPATH,
88 IREGEX, LINKS, LOCAL, LPAREN, LS, MAXDEPTH, MINDEPTH, MMIN, MOUNT,
89 MTIME, NAME, NCPIO, NEWER, NOGRP, NOT, NOUSER, OK, OR, PATH, PERM,
90 PRINT0, PRUNE, REGEX, RPAREN, SIZE, TYPE, VARARGS, XATTR, DELETE
91 };
92
93 enum Type
94 {
95 Unary, Id, Num, Str, Exec, Cpio, Op
96 };
97
98 struct Args
99 {
100 char name[10];
101 enum Command action;
102 enum Type type;
103 };
104
105 /*
106 * Except for pathnames, these are the only legal arguments
107 */
108 static struct Args commands[] =
109 {
110 "!", NOT, Op,
111 "(", LPAREN, Unary,
112 ")", RPAREN, Unary,
113 "-a", AND, Op,
114 "-acl", ACL, Unary,
115 "-amin", AMIN, Num,
116 "-and", AND, Op,
117 "-atime", ATIME, Num,
118 "-cmin", CMIN, Num,
119 "-cpio", CPIO, Cpio,
120 "-ctime", CTIME, Num,
121 "-depth", DEPTH, Unary,
122 "-delete", DELETE, Unary,
123 "-exec", EXEC, Exec,
124 "-follow", FOLLOW, Unary,
125 "-fstype", FSTYPE, Str,
126 "-group", F_GROUP, Num,
127 "-groupacl", F_GROUPACL, Num,
128 "-iname", INAME, Str,
129 "-inum", INUM, Num,
130 "-ipath", IPATH, Str,
131 "-iregex", IREGEX, Str,
132 "-links", LINKS, Num,
133 "-local", LOCAL, Unary,
134 "-ls", LS, Unary,
135 "-maxdepth", MAXDEPTH, Num,
136 "-mindepth", MINDEPTH, Num,
137 "-mmin", MMIN, Num,
138 "-mount", MOUNT, Unary,
139 "-mtime", MTIME, Num,
140 "-name", NAME, Str,
141 "-ncpio", NCPIO, Cpio,
142 "-newer", NEWER, Str,
143 "-nogroup", NOGRP, Unary,
144 "-not", NOT, Op,
145 "-nouser", NOUSER, Unary,
146 "-o", OR, Op,
147 "-ok", OK, Exec,
148 "-or", OR, Op,
149 "-path", PATH, Str,
150 "-perm", PERM, Num,
151 "-print", PRINT, Unary,
152 "-print0", PRINT0, Unary,
153 "-prune", PRUNE, Unary,
154 "-regex", REGEX, Str,
155 "-size", SIZE, Num,
156 "-type", TYPE, Num,
157 "-user", F_USER, Num,
158 "-useracl", F_USERACL, Num,
159 "-xattr", XATTR, Unary,
160 "-xdev", MOUNT, Unary,
161 NULL, 0, 0
162 };
163
164 union Item
165 {
166 struct Node *np;
167 struct Arglist *vp;
168 time_t t;
169 char *cp;
170 char **ap;
171 long l;
172 int i;
173 long long ll;
174 };
175
176 struct Node
177 {
178 struct Node *next;
179 enum Command action;
180 enum Type type;
181 union Item first;
182 union Item second;
183 };
184
185 /* if no -print, -exec or -ok replace "expression" with "(expression) -print" */
186 static struct Node PRINT_NODE = { 0, PRINT, 0, 0};
187 static struct Node LPAREN_NODE = { 0, LPAREN, 0, 0};
188
189
190 /*
191 * Prototype variable size arglist buffer
192 */
193
194 struct Arglist
195 {
196 struct Arglist *next;
197 char *end;
198 char *nextstr;
199 char **firstvar;
200 char **nextvar;
201 char *arglist[1];
202 };
203
204
205 static int compile();
206 static int execute();
207 static int doexec(char *, char **, int *);
208 static int dodelete(char *, struct stat *, struct FTW *);
209 static struct Args *lookup();
210 static int ok();
211 static void usage(void) __NORETURN;
212 static struct Arglist *varargs();
213 static int list();
214 static char *getgroup();
215 static FILE *cmdopen();
216 static int cmdclose();
217 static char *getshell();
218 static void init_remote_fs();
219 static char *getname();
220 static int readmode();
221 static mode_t getmode();
222 static char *gettail();
223
224
225 static int walkflags = FTW_CHDIR|FTW_PHYS|FTW_ANYERR|FTW_NOLOOP;
226 static struct Node *topnode;
227 static struct Node *freenode; /* next free node we may use later */
228 static char *cpio[] = { "cpio", "-o", 0 };
229 static char *ncpio[] = { "cpio", "-oc", 0 };
230 static char *cpiol[] = { "cpio", "-oL", 0 };
231 static char *ncpiol[] = { "cpio", "-ocL", 0 };
232 static time_t now;
233 static FILE *output;
234 static char *dummyarg = (char *)-1;
235 static int lastval;
236 static int varsize;
237 static struct Arglist *lastlist;
238 static char *cmdname;
239 static char *remote_fstypes[N_FSTYPES+1];
240 static int fstype_index = 0;
241 static int action_expression = 0; /* -print, -exec, or -ok */
242 static int error = 0;
243 static int paren_cnt = 0; /* keeps track of parentheses */
244 static int Eflag = 0;
245 static int hflag = 0;
246 static int lflag = 0;
247 /* set when doexec()-invoked utility returns non-zero */
248 static int exec_exitcode = 0;
249 static regex_t *preg = NULL;
250 static int npreg = 0;
251 static int mindepth = -1, maxdepth = -1;
252 extern char **environ;
253
254 int
255 main(int argc, char **argv)
256 {
257 char *cp;
258 int c;
259 int paths;
260 char *cwdpath;
261
262 (void) setlocale(LC_ALL, "");
263 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
264 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
265 #endif
266 (void) textdomain(TEXT_DOMAIN);
267
268 cmdname = argv[0];
269 if (time(&now) == (time_t)(-1)) {
270 (void) fprintf(stderr, gettext("%s: time() %s\n"),
271 cmdname, strerror(errno));
272 exit(1);
273 }
274 while ((c = getopt(argc, argv, "EHL")) != -1) {
275 switch (c) {
276 case 'E':
277 Eflag = 1;
278 break;
279 case 'H':
280 hflag = 1;
281 lflag = 0;
282 break;
283 case 'L':
284 hflag = 0;
285 lflag = 1;
286 break;
287 case '?':
288 usage();
289 break;
290 }
291 }
292
293 argc -= optind;
294 argv += optind;
295
296 if (argc < 1) {
297 (void) fprintf(stderr,
298 gettext("%s: insufficient number of arguments\n"), cmdname);
299 usage();
300 }
301
302 for (paths = 0; (cp = argv[paths]) != 0; ++paths) {
303 if (*cp == '-')
304 break;
305 else if ((*cp == '!' || *cp == '(') && *(cp+1) == 0)
306 break;
307 }
308
309 if (paths == 0) /* no path-list */
310 usage();
311
312 output = stdout;
313
314 /* lflag is the same as -follow */
315 if (lflag)
316 walkflags &= ~FTW_PHYS;
317
318 /* allocate enough space for the compiler */
319 topnode = malloc((argc + 1) * sizeof (struct Node));
320 (void) memset(topnode, 0, (argc + 1) * sizeof (struct Node));
321
322 if (compile(argv + paths, topnode, &action_expression) == 0) {
323 /* no expression, default to -print */
324 (void) memcpy(topnode, &PRINT_NODE, sizeof (struct Node));
325 } else if (!action_expression) {
326 /*
327 * if no action expression, insert an LPAREN node above topnode,
328 * with a PRINT node as its next node
329 */
330 struct Node *savenode;
331
332 if (freenode == NULL) {
333 (void) fprintf(stderr, gettext("%s: can't append -print"
334 " implicitly; try explicit -print option\n"),
335 cmdname);
336 exit(1);
337 }
338 savenode = topnode;
339 topnode = freenode++;
340 (void) memcpy(topnode, &LPAREN_NODE, sizeof (struct Node));
341 topnode->next = freenode;
342 topnode->first.np = savenode;
343 (void) memcpy(topnode->next, &PRINT_NODE, sizeof (struct Node));
344 }
345
346 while (paths--) {
347 char *curpath;
348 struct stat sb;
349
350 curpath = *(argv++);
351
352 /*
353 * If -H is specified, it means we walk the first
354 * level (pathname on command line) logically, following
355 * symlinks, but lower levels are walked physically.
356 * We use our own secret interface to nftw() to change
357 * the from stat to lstat after the top level is walked.
358 */
359 if (hflag) {
360 if (stat(curpath, &sb) < 0 && errno == ENOENT)
361 walkflags &= ~FTW_HOPTION;
362 else
363 walkflags |= FTW_HOPTION;
364 }
365
366 /*
367 * We need this check as nftw needs a CWD and we have no
368 * way of returning back from that code with a meaningful
369 * error related to this
370 */
371 if ((cwdpath = getcwd(NULL, PATH_MAX)) == NULL) {
372 if ((errno == EACCES) && (walkflags & FTW_CHDIR)) {
373 /*
374 * A directory above cwd is inaccessible,
375 * so don't do chdir(2)s. Slower, but at least
376 * it works.
377 */
378 walkflags &= ~FTW_CHDIR;
379 free(cwdpath);
380 } else {
381 (void) fprintf(stderr,
382 gettext("%s : cannot get the current "
383 "working directory\n"), cmdname);
384 exit(1);
385 }
386 } else
387 free(cwdpath);
388
389
390 if (nftw(curpath, execute, 1000, walkflags)) {
391 (void) fprintf(stderr,
392 gettext("%s: cannot open %s: %s\n"),
393 cmdname, curpath, strerror(errno));
394 error = 1;
395 }
396
397 }
398
399 /* execute any remaining variable length lists */
400 while (lastlist) {
401 if (lastlist->end != lastlist->nextstr) {
402 *lastlist->nextvar = 0;
403 (void) doexec((char *)0, lastlist->arglist,
404 &exec_exitcode);
405 }
406 lastlist = lastlist->next;
407 }
408 if (output != stdout)
409 return (cmdclose(output));
410 return ((exec_exitcode != 0) ? exec_exitcode : error);
411 }
412
413 /*
414 * compile the arguments
415 */
416
417 static int
418 compile(argv, np, actionp)
419 char **argv;
420 struct Node *np;
421 int *actionp;
422 {
423 char *b;
424 char **av;
425 struct Node *oldnp = topnode;
426 struct Args *argp;
427 char **com;
428 int i;
429 enum Command wasop = PRINT;
430
431 if (init_yes() < 0) {
432 (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
433 strerror(errno));
434 exit(1);
435 }
436
437 for (av = argv; *av && (argp = lookup(*av)); av++) {
438 np->next = 0;
439 np->action = argp->action;
440 np->type = argp->type;
441 np->second.i = 0;
442 if (argp->type == Op) {
443 if (wasop == NOT || (wasop && np->action != NOT)) {
444 (void) fprintf(stderr,
445 gettext("%s: operand follows operand\n"),
446 cmdname);
447 exit(1);
448 }
449 if (np->action != NOT && oldnp == 0)
450 goto err;
451 wasop = argp->action;
452 } else {
453 wasop = PRINT;
454 if (argp->type != Unary) {
455 if (!(b = *++av)) {
456 (void) fprintf(stderr,
457 gettext("%s: incomplete statement\n"),
458 cmdname);
459 exit(1);
460 }
461 if (argp->type == Num) {
462 if (((argp->action == MAXDEPTH) ||
463 (argp->action == MINDEPTH)) &&
464 ((int)strtol(b, (char **)NULL,
465 10) < 0))
466 errx(1,
467 gettext("%s: value must be positive"),
468 (argp->action == MAXDEPTH) ?
469 "maxdepth" : "mindepth");
470 if ((argp->action != PERM) ||
471 (*b != '+')) {
472 if (*b == '+' || *b == '-') {
473 np->second.i = *b;
474 b++;
475 }
476 }
477 }
478 }
479 }
480 switch (argp->action) {
481 case AND:
482 break;
483 case NOT:
484 break;
485 case OR:
486 np->first.np = topnode;
487 topnode = np;
488 oldnp->next = 0;
489 break;
490
491 case LPAREN: {
492 struct Node *save = topnode;
493 topnode = np+1;
494 paren_cnt++;
495 i = compile(++av, topnode, actionp);
496 np->first.np = topnode;
497 topnode = save;
498 av += i;
499 oldnp = np;
500 np += i + 1;
501 oldnp->next = np;
502 continue;
503 }
504
505 case RPAREN:
506 if (paren_cnt <= 0) {
507 (void) fprintf(stderr,
508 gettext("%s: unmatched ')'\n"),
509 cmdname);
510 exit(1);
511 }
512 paren_cnt--;
513 if (oldnp == 0)
514 goto err;
515 if (oldnp->type == Op) {
516 (void) fprintf(stderr,
517 gettext("%s: cannot immediately"
518 " follow an operand with ')'\n"),
519 cmdname);
520 exit(1);
521 }
522 oldnp->next = 0;
523 return (av-argv);
524
525 case FOLLOW:
526 walkflags &= ~FTW_PHYS;
527 break;
528 case MOUNT:
529 walkflags |= FTW_MOUNT;
530 break;
531 case DEPTH:
532 walkflags |= FTW_DEPTH;
533 break;
534 case DELETE:
535 walkflags |= (FTW_DEPTH | FTW_PHYS);
536 walkflags &= ~FTW_CHDIR;
537 (*actionp)++;
538 break;
539
540 case LOCAL:
541 np->first.l = 0L;
542 np->first.ll = 0LL;
543 np->second.i = '+';
544 /*
545 * Make it compatible to df -l for
546 * future enhancement. So, anything
547 * that is not remote, then it is
548 * local.
549 */
550 init_remote_fs();
551 break;
552
553 case SIZE:
554 if (b[strlen(b)-1] == 'c')
555 np->action = CSIZE;
556 /*FALLTHROUGH*/
557 case INUM:
558 np->first.ll = atoll(b);
559 break;
560
561 case CMIN:
562 case CTIME:
563 case MMIN:
564 case MTIME:
565 case AMIN:
566 case ATIME:
567 case LINKS:
568 np->first.l = atol(b);
569 break;
570
571 case F_USER:
572 case F_GROUP:
573 case F_USERACL:
574 case F_GROUPACL: {
575 struct passwd *pw;
576 struct group *gr;
577 long value;
578 char *q;
579
580 value = -1;
581 if (argp->action == F_USER ||
582 argp->action == F_USERACL) {
583 if ((pw = getpwnam(b)) != 0)
584 value = (long)pw->pw_uid;
585 } else {
586 if ((gr = getgrnam(b)) != 0)
587 value = (long)gr->gr_gid;
588 }
589 if (value == -1) {
590 errno = 0;
591 value = strtol(b, &q, 10);
592 if (errno != 0 || q == b || *q != '\0') {
593 (void) fprintf(stderr, gettext(
594 "%s: cannot find %s name\n"),
595 cmdname, *av);
596 exit(1);
597 }
598 }
599 np->first.l = value;
600 break;
601 }
602
603 case EXEC:
604 case OK:
605 walkflags &= ~FTW_CHDIR;
606 np->first.ap = av;
607 (*actionp)++;
608 for (;;) {
609 if ((b = *av) == 0) {
610 (void) fprintf(stderr,
611 gettext("%s: incomplete statement\n"),
612 cmdname);
613 exit(1);
614 }
615 if (strcmp(b, ";") == 0) {
616 *av = 0;
617 break;
618 } else if (strcmp(b, "{}") == 0)
619 *av = dummyarg;
620 else if (strcmp(b, "+") == 0 &&
621 av[-1] == dummyarg &&
622 np->action == EXEC) {
623 av[-1] = 0;
624 np->first.vp = varargs(np->first.ap);
625 np->action = VARARGS;
626 break;
627 }
628 av++;
629 }
630 break;
631
632 case NAME:
633 case INAME:
634 case PATH:
635 case IPATH:
636 np->first.cp = b;
637 break;
638 case REGEX:
639 case IREGEX: {
640 int error;
641 size_t errlen;
642 char *errmsg;
643
644 if ((preg = realloc(preg, (npreg + 1) *
645 sizeof (regex_t))) == NULL)
646 err(1, "realloc");
647 if ((error = regcomp(&preg[npreg], b,
648 ((np->action == IREGEX) ? REG_ICASE : 0) |
649 ((Eflag) ? REG_EXTENDED : 0))) != 0) {
650 errlen = regerror(error, &preg[npreg], NULL, 0);
651 if ((errmsg = malloc(errlen)) == NULL)
652 err(1, "malloc");
653 (void) regerror(error, &preg[npreg], errmsg,
654 errlen);
655 errx(1, gettext("RE error: %s"), errmsg);
656 }
657 npreg++;
658 break;
659 }
660 case PERM:
661 if (*b == '-')
662 ++b;
663
664 if (readmode(b) != NULL) {
665 (void) fprintf(stderr, gettext(
666 "find: -perm: Bad permission string\n"));
667 usage();
668 }
669 np->first.l = (long)getmode((mode_t)0);
670 break;
671 case TYPE:
672 i = *b;
673 np->first.l =
674 i == 'd' ? S_IFDIR :
675 i == 'b' ? S_IFBLK :
676 i == 'c' ? S_IFCHR :
677 #ifdef S_IFIFO
678 i == 'p' ? S_IFIFO :
679 #endif
680 i == 'f' ? S_IFREG :
681 #ifdef S_IFLNK
682 i == 'l' ? S_IFLNK :
683 #endif
684 #ifdef S_IFSOCK
685 i == 's' ? S_IFSOCK :
686 #endif
687 #ifdef S_IFDOOR
688 i == 'D' ? S_IFDOOR :
689 #endif
690 0;
691 break;
692
693 case CPIO:
694 if (walkflags & FTW_PHYS)
695 com = cpio;
696 else
697 com = cpiol;
698 goto common;
699
700 case NCPIO: {
701 FILE *fd;
702
703 if (walkflags & FTW_PHYS)
704 com = ncpio;
705 else
706 com = ncpiol;
707 common:
708 /* set up cpio */
709 if ((fd = fopen(b, "w")) == NULL) {
710 (void) fprintf(stderr,
711 gettext("%s: cannot create %s\n"),
712 cmdname, b);
713 exit(1);
714 }
715
716 np->first.l = (long)cmdopen("cpio", com, "w", fd);
717 (void) fclose(fd);
718 walkflags |= FTW_DEPTH;
719 np->action = CPIO;
720 }
721 /*FALLTHROUGH*/
722 case PRINT:
723 case PRINT0:
724 (*actionp)++;
725 break;
726
727 case NEWER: {
728 struct stat statb;
729 if (stat(b, &statb) < 0) {
730 (void) fprintf(stderr,
731 gettext("%s: cannot access %s\n"),
732 cmdname, b);
733 exit(1);
734 }
735 np->first.l = statb.st_mtime;
736 np->second.i = '+';
737 break;
738 }
739
740 case PRUNE:
741 case NOUSER:
742 case NOGRP:
743 break;
744 case FSTYPE:
745 np->first.cp = b;
746 break;
747 case LS:
748 (*actionp)++;
749 break;
750 case XATTR:
751 break;
752 case ACL:
753 break;
754 case MAXDEPTH:
755 maxdepth = (int)strtol(b, (char **)NULL, 10);
756 break;
757 case MINDEPTH:
758 mindepth = (int)strtol(b, (char **)NULL, 10);
759 break;
760 }
761
762 oldnp = np++;
763 oldnp->next = np;
764 }
765
766 if ((*av) || (wasop))
767 goto err;
768
769 if (paren_cnt != 0) {
770 (void) fprintf(stderr, gettext("%s: unmatched '('\n"),
771 cmdname);
772 exit(1);
773 }
774
775 /* just before returning, save next free node from the list */
776 freenode = oldnp->next;
777 oldnp->next = 0;
778 return (av-argv);
779 err:
780 if (*av)
781 (void) fprintf(stderr,
782 gettext("%s: bad option %s\n"), cmdname, *av);
783 else
784 (void) fprintf(stderr, gettext("%s: bad option\n"), cmdname);
785 usage();
786 /*NOTREACHED*/
787 }
788
789 /*
790 * print out a usage message
791 */
792
793 static void
794 usage(void)
795 {
796 (void) fprintf(stderr,
797 gettext("%s: [-E] [-H | -L] path-list predicate-list\n"), cmdname);
798 exit(1);
799 }
800
801 /*
802 * This is the function that gets executed at each node
803 */
804
805 static int
806 execute(name, statb, type, state)
807 char *name;
808 struct stat *statb;
809 int type;
810 struct FTW *state;
811 {
812 struct Node *np = topnode;
813 int val;
814 time_t t;
815 long l;
816 long long ll;
817 int not = 1;
818 char *filename;
819 int cnpreg = 0;
820
821 if (type == FTW_NS) {
822 (void) fprintf(stderr, gettext("%s: stat() error %s: %s\n"),
823 cmdname, name, strerror(errno));
824 error = 1;
825 return (0);
826 } else if (type == FTW_DNR) {
827 (void) fprintf(stderr, gettext("%s: cannot read dir %s: %s\n"),
828 cmdname, name, strerror(errno));
829 error = 1;
830 } else if (type == FTW_SLN && lflag == 1) {
831 (void) fprintf(stderr,
832 gettext("%s: cannot follow symbolic link %s: %s\n"),
833 cmdname, name, strerror(errno));
834 error = 1;
835 } else if (type == FTW_DL) {
836 (void) fprintf(stderr, gettext("%s: cycle detected for %s\n"),
837 cmdname, name);
838 error = 1;
839 return (0);
840 }
841
842 if ((maxdepth != -1 && state->level > maxdepth) ||
843 (mindepth != -1 && state->level < mindepth))
844 return (0);
845
846 while (np) {
847 switch (np->action) {
848 case NOT:
849 not = !not;
850 np = np->next;
851 continue;
852
853 case AND:
854 np = np->next;
855 continue;
856
857 case OR:
858 if (np->first.np == np) {
859 /*
860 * handle naked OR (no term on left hand side)
861 */
862 (void) fprintf(stderr,
863 gettext("%s: invalid -o construction\n"),
864 cmdname);
865 exit(2);
866 }
867 /* FALLTHROUGH */
868 case LPAREN: {
869 struct Node *save = topnode;
870 topnode = np->first.np;
871 (void) execute(name, statb, type, state);
872 val = lastval;
873 topnode = save;
874 if (np->action == OR) {
875 if (val)
876 return (0);
877 val = 1;
878 }
879 break;
880 }
881
882 case LOCAL: {
883 int nremfs;
884 val = 1;
885 /*
886 * If file system type matches the remote
887 * file system type, then it is not local.
888 */
889 for (nremfs = 0; nremfs < fstype_index; nremfs++) {
890 if (strcmp(remote_fstypes[nremfs],
891 statb->st_fstype) == 0) {
892 val = 0;
893 break;
894 }
895 }
896 break;
897 }
898
899 case TYPE:
900 l = (long)statb->st_mode&S_IFMT;
901 goto num;
902
903 case PERM:
904 l = (long)statb->st_mode&07777;
905 if (np->second.i == '-')
906 val = ((l&np->first.l) == np->first.l);
907 else
908 val = (l == np->first.l);
909 break;
910
911 case INUM:
912 ll = (long long)statb->st_ino;
913 goto llnum;
914 case NEWER:
915 l = statb->st_mtime;
916 goto num;
917 case ATIME:
918 t = statb->st_atime;
919 goto days;
920 case CTIME:
921 t = statb->st_ctime;
922 goto days;
923 case MTIME:
924 t = statb->st_mtime;
925 days:
926 l = (now-t)/A_DAY;
927 goto num;
928 case MMIN:
929 t = statb->st_mtime;
930 goto mins;
931 case AMIN:
932 t = statb->st_atime;
933 goto mins;
934 case CMIN:
935 t = statb->st_ctime;
936 goto mins;
937 mins:
938 l = (now-t)/A_MIN;
939 goto num;
940 case CSIZE:
941 ll = (long long)statb->st_size;
942 goto llnum;
943 case SIZE:
944 ll = (long long)round(statb->st_size, BLKSIZ)/BLKSIZ;
945 goto llnum;
946 case F_USER:
947 l = (long)statb->st_uid;
948 goto num;
949 case F_GROUP:
950 l = (long)statb->st_gid;
951 goto num;
952 case LINKS:
953 l = (long)statb->st_nlink;
954 goto num;
955 llnum:
956 if (np->second.i == '+')
957 val = (ll > np->first.ll);
958 else if (np->second.i == '-')
959 val = (ll < np->first.ll);
960 else
961 val = (ll == np->first.ll);
962 break;
963 num:
964 if (np->second.i == '+')
965 val = (l > np->first.l);
966 else if (np->second.i == '-')
967 val = (l < np->first.l);
968 else
969 val = (l == np->first.l);
970 break;
971 case OK:
972 val = ok(name, np->first.ap);
973 break;
974 case EXEC:
975 val = doexec(name, np->first.ap, NULL);
976 break;
977 case DELETE:
978 val = dodelete(name, statb, state);
979 break;
980
981 case VARARGS: {
982 struct Arglist *ap = np->first.vp;
983 char *cp;
984 cp = ap->nextstr - (strlen(name)+1);
985 if (cp >= (char *)(ap->nextvar+3)) {
986 /* there is room just copy the name */
987 val = 1;
988 (void) strcpy(cp, name);
989 *ap->nextvar++ = cp;
990 ap->nextstr = cp;
991 } else {
992 /* no more room, exec command */
993 *ap->nextvar++ = name;
994 *ap->nextvar = 0;
995 val = 1;
996 (void) doexec((char *)0, ap->arglist,
997 &exec_exitcode);
998 ap->nextstr = ap->end;
999 ap->nextvar = ap->firstvar;
1000 }
1001 break;
1002 }
1003
1004 case DEPTH:
1005 case MOUNT:
1006 case FOLLOW:
1007 val = 1;
1008 break;
1009
1010 case NAME:
1011 case INAME:
1012 case PATH:
1013 case IPATH: {
1014 char *path;
1015 int fnmflags = 0;
1016
1017 if (np->action == INAME || np->action == IPATH)
1018 fnmflags = FNM_IGNORECASE;
1019
1020 /*
1021 * basename(3c) may modify name, so
1022 * we need to pass another string
1023 */
1024 if ((path = strdup(name)) == NULL) {
1025 (void) fprintf(stderr,
1026 gettext("%s: cannot strdup() %s: %s\n"),
1027 cmdname, name, strerror(errno));
1028 exit(2);
1029 }
1030 /*
1031 * XPG4 find should not treat a leading '.' in a
1032 * filename specially for pattern matching.
1033 * /usr/bin/find will not pattern match a leading
1034 * '.' in a filename, unless '.' is explicitly
1035 * specified.
1036 */
1037 #ifndef XPG4
1038 fnmflags |= FNM_PERIOD;
1039 #endif
1040
1041 val = !fnmatch(np->first.cp,
1042 (np->action == NAME || np->action == INAME)
1043 ? basename(path) : path, fnmflags);
1044 free(path);
1045 break;
1046 }
1047
1048 case PRUNE:
1049 if (type == FTW_D)
1050 state->quit = FTW_PRUNE;
1051 val = 1;
1052 break;
1053 case NOUSER:
1054 val = ((getpwuid(statb->st_uid)) == 0);
1055 break;
1056 case NOGRP:
1057 val = ((getgrgid(statb->st_gid)) == 0);
1058 break;
1059 case FSTYPE:
1060 val = (strcmp(np->first.cp, statb->st_fstype) == 0);
1061 break;
1062 case CPIO:
1063 output = (FILE *)np->first.l;
1064 (void) fprintf(output, "%s\n", name);
1065 val = 1;
1066 break;
1067 case PRINT:
1068 case PRINT0:
1069 (void) fprintf(stdout, "%s%c", name,
1070 (np->action == PRINT) ? '\n' : '\0');
1071 val = 1;
1072 break;
1073 case LS:
1074 (void) list(name, statb);
1075 val = 1;
1076 break;
1077 case XATTR:
1078 filename = (walkflags & FTW_CHDIR) ?
1079 gettail(name) : name;
1080 val = (pathconf(filename, _PC_XATTR_EXISTS) == 1);
1081 break;
1082 case ACL:
1083 /*
1084 * Need to get the tail of the file name, since we have
1085 * already chdir()ed into the directory (performed in
1086 * nftw()) of the file
1087 */
1088 filename = (walkflags & FTW_CHDIR) ?
1089 gettail(name) : name;
1090 val = acl_trivial(filename);
1091 break;
1092 case F_USERACL:
1093 case F_GROUPACL: {
1094 int i;
1095 acl_t *acl;
1096 void *acl_entry;
1097 aclent_t *p1;
1098 ace_t *p2;
1099
1100 filename = (walkflags & FTW_CHDIR) ?
1101 gettail(name) : name;
1102 val = 0;
1103 if (acl_get(filename, 0, &acl) != 0)
1104 break;
1105 for (i = 0, acl_entry = acl->acl_aclp;
1106 i != acl->acl_cnt; i++) {
1107 if (acl->acl_type == ACLENT_T) {
1108 p1 = (aclent_t *)acl_entry;
1109 if (p1->a_id == np->first.l) {
1110 val = 1;
1111 acl_free(acl);
1112 break;
1113 }
1114 } else {
1115 p2 = (ace_t *)acl_entry;
1116 if (p2->a_who == np->first.l) {
1117 val = 1;
1118 acl_free(acl);
1119 break;
1120 }
1121 }
1122 acl_entry = ((char *)acl_entry +
1123 acl->acl_entry_size);
1124 }
1125 acl_free(acl);
1126 break;
1127 }
1128 case IREGEX:
1129 case REGEX: {
1130 regmatch_t pmatch;
1131
1132 val = 0;
1133 if (regexec(&preg[cnpreg], name, 1, &pmatch, NULL) == 0)
1134 val = ((pmatch.rm_so == 0) &&
1135 (pmatch.rm_eo == strlen(name)));
1136 cnpreg++;
1137 break;
1138 }
1139 case MAXDEPTH:
1140 if (state->level == maxdepth && type == FTW_D)
1141 state->quit = FTW_PRUNE;
1142 /* FALLTHROUGH */
1143 case MINDEPTH:
1144 val = 1;
1145 break;
1146 }
1147 /*
1148 * evaluate 'val' and 'not' (exclusive-or)
1149 * if no inversion (not == 1), return only when val == 0
1150 * (primary not true). Otherwise, invert the primary
1151 * and return when the primary is true.
1152 * 'Lastval' saves the last result (fail or pass) when
1153 * returning back to the calling routine.
1154 */
1155 if (val^not) {
1156 lastval = 0;
1157 return (0);
1158 }
1159 lastval = 1;
1160 not = 1;
1161 np = np->next;
1162 }
1163 return (0);
1164 }
1165
1166 /*
1167 * code for the -ok option
1168 */
1169
1170 static int
1171 ok(name, argv)
1172 char *name;
1173 char *argv[];
1174 {
1175 int c;
1176 int i = 0;
1177 char resp[LINE_MAX + 1];
1178
1179 (void) fflush(stdout); /* to flush possible `-print' */
1180
1181 if ((*argv != dummyarg) && (strcmp(*argv, name)))
1182 (void) fprintf(stderr, "< %s ... %s >? ", *argv, name);
1183 else
1184 (void) fprintf(stderr, "< {} ... %s >? ", name);
1185
1186 (void) fflush(stderr);
1187
1188 while ((c = getchar()) != '\n') {
1189 if (c == EOF)
1190 exit(2);
1191 if (i < LINE_MAX)
1192 resp[i++] = c;
1193 }
1194 resp[i] = '\0';
1195
1196 if (yes_check(resp))
1197 return (doexec(name, argv, NULL));
1198 else
1199 return (0);
1200 }
1201
1202 /*
1203 * execute argv with {} replaced by name
1204 *
1205 * Per XPG6, find must exit non-zero if an invocation through
1206 * -exec, punctuated by a plus sign, exits non-zero, so set
1207 * exitcode if we see a non-zero exit.
1208 * exitcode should be NULL when -exec or -ok is not punctuated
1209 * by a plus sign.
1210 */
1211
1212 static int
1213 doexec(char *name, char *argv[], int *exitcode)
1214 {
1215 char *cp;
1216 char **av = argv;
1217 char *newargs[1 + SHELL_MAXARGS + 1];
1218 int dummyseen = 0;
1219 int i, j, status, rc, r = 0;
1220 int exit_status = 0;
1221 pid_t pid, pid1;
1222
1223 (void) fflush(stdout); /* to flush possible `-print' */
1224 if (name) {
1225 while (cp = *av++) {
1226 if (cp == dummyarg) {
1227 dummyseen = 1;
1228 av[-1] = name;
1229 }
1230
1231 }
1232 }
1233 if (argv[0] == NULL) /* null command line */
1234 return (r);
1235
1236 if ((pid = fork()) == -1) {
1237 /* fork failed */
1238 if (exitcode != NULL)
1239 *exitcode = 1;
1240 return (0);
1241 }
1242 if (pid != 0) {
1243 /* parent */
1244 do {
1245 /* wait for child to exit */
1246 if ((rc = wait(&r)) == -1 && errno != EINTR) {
1247 (void) fprintf(stderr,
1248 gettext("wait failed %s"), strerror(errno));
1249
1250 if (exitcode != NULL)
1251 *exitcode = 1;
1252 return (0);
1253 }
1254 } while (rc != pid);
1255 } else {
1256 /* child */
1257 (void) execvp(argv[0], argv);
1258 if (errno != E2BIG)
1259 exit(1);
1260
1261 /*
1262 * We are in a situation where argv[0] points to a
1263 * script without the interpreter line, e.g. #!/bin/sh.
1264 * execvp() will execute either /usr/bin/sh or
1265 * /usr/xpg4/bin/sh against the script, and you will be
1266 * limited to SHELL_MAXARGS arguments. If you try to
1267 * pass more than SHELL_MAXARGS arguments, execvp()
1268 * fails with E2BIG.
1269 * See usr/src/lib/libc/port/gen/execvp.c.
1270 *
1271 * In this situation, process the argument list by
1272 * packets of SHELL_MAXARGS arguments with respect of
1273 * the following rules:
1274 * 1. the invocations have to complete before find exits
1275 * 2. only one invocation can be running at a time
1276 */
1277
1278 i = 1;
1279 newargs[0] = argv[0];
1280
1281 while (argv[i]) {
1282 j = 1;
1283 while (j <= SHELL_MAXARGS && argv[i]) {
1284 newargs[j++] = argv[i++];
1285 }
1286 newargs[j] = NULL;
1287
1288 if ((pid1 = fork()) == -1) {
1289 /* fork failed */
1290 exit(1);
1291 }
1292 if (pid1 == 0) {
1293 /* child */
1294 (void) execvp(newargs[0], newargs);
1295 exit(1);
1296 }
1297
1298 status = 0;
1299
1300 do {
1301 /* wait for the child to exit */
1302 if ((rc = wait(&status)) == -1 &&
1303 errno != EINTR) {
1304 (void) fprintf(stderr,
1305 gettext("wait failed %s"),
1306 strerror(errno));
1307 exit(1);
1308 }
1309 } while (rc != pid1);
1310
1311 if (status)
1312 exit_status = 1;
1313 }
1314 /* all the invocations have completed */
1315 exit(exit_status);
1316 }
1317
1318 if (name && dummyseen) {
1319 for (av = argv; cp = *av++; ) {
1320 if (cp == name)
1321 av[-1] = dummyarg;
1322 }
1323 }
1324
1325 if (r && exitcode != NULL)
1326 *exitcode = 3; /* use to indicate error in cmd invocation */
1327
1328 return (!r);
1329 }
1330
1331 static int
1332 dodelete(char *name, struct stat *statb, struct FTW *state)
1333 {
1334 char *fn;
1335 int rc = 0;
1336
1337 /* restrict symlinks */
1338 if ((walkflags & FTW_PHYS) == 0) {
1339 (void) fprintf(stderr,
1340 gettext("-delete is not allowed when symlinks are "
1341 "followed.\n"));
1342 return (1);
1343 }
1344
1345 fn = name + state->base;
1346 if (strcmp(fn, ".") == 0) {
1347 /* nothing to do */
1348 return (1);
1349 }
1350
1351 if (strchr(fn, '/') != NULL) {
1352 (void) fprintf(stderr,
1353 gettext("-delete with relative path is unsafe."));
1354 return (1);
1355 }
1356
1357 if (S_ISDIR(statb->st_mode)) {
1358 /* delete directory */
1359 rc = rmdir(name);
1360 } else {
1361 /* delete file */
1362 rc = unlink(name);
1363 }
1364
1365 if (rc < 0) {
1366 /* operation failed */
1367 (void) fprintf(stderr, gettext("delete failed %s: %s\n"),
1368 name, strerror(errno));
1369 return (1);
1370 }
1371
1372 return (1);
1373 }
1374
1375 /*
1376 * Table lookup routine
1377 */
1378 static struct Args *
1379 lookup(word)
1380 char *word;
1381 {
1382 struct Args *argp = commands;
1383 int second;
1384 if (word == 0 || *word == 0)
1385 return (0);
1386 second = word[1];
1387 while (*argp->name) {
1388 if (second == argp->name[1] && strcmp(word, argp->name) == 0)
1389 return (argp);
1390 argp++;
1391 }
1392 return (0);
1393 }
1394
1395
1396 /*
1397 * Get space for variable length argument list
1398 */
1399
1400 static struct Arglist *
1401 varargs(com)
1402 char **com;
1403 {
1404 struct Arglist *ap;
1405 int n;
1406 char **ep;
1407 if (varsize == 0) {
1408 n = 2*sizeof (char **);
1409 for (ep = environ; *ep; ep++)
1410 n += (strlen(*ep)+sizeof (ep) + 1);
1411 varsize = sizeof (struct Arglist)+ARG_MAX-PATH_MAX-n-1;
1412 }
1413 ap = (struct Arglist *)malloc(varsize+1);
1414 ap->end = (char *)ap + varsize;
1415 ap->nextstr = ap->end;
1416 ap->nextvar = ap->arglist;
1417 while (*ap->nextvar++ = *com++);
1418 ap->nextvar--;
1419 ap->firstvar = ap->nextvar;
1420 ap->next = lastlist;
1421 lastlist = ap;
1422 return (ap);
1423 }
1424
1425 /*
1426 * filter command support
1427 * fork and exec cmd(argv) according to mode:
1428 *
1429 * "r" with fp as stdin of cmd (default stdin), cmd stdout returned
1430 * "w" with fp as stdout of cmd (default stdout), cmd stdin returned
1431 */
1432
1433 #define CMDERR ((1<<8)-1) /* command error exit code */
1434 #define MAXCMDS 8 /* max # simultaneous cmdopen()'s */
1435
1436 static struct /* info for each cmdopen() */
1437 {
1438 FILE *fp; /* returned by cmdopen() */
1439 pid_t pid; /* pid used by cmdopen() */
1440 } cmdproc[MAXCMDS];
1441
1442 static FILE *
1443 cmdopen(cmd, argv, mode, fp)
1444 char *cmd;
1445 char **argv;
1446 char *mode;
1447 FILE *fp;
1448 {
1449 int proc;
1450 int cmdfd;
1451 int usrfd;
1452 int pio[2];
1453
1454 switch (*mode) {
1455 case 'r':
1456 cmdfd = 1;
1457 usrfd = 0;
1458 break;
1459 case 'w':
1460 cmdfd = 0;
1461 usrfd = 1;
1462 break;
1463 default:
1464 return (0);
1465 }
1466
1467 for (proc = 0; proc < MAXCMDS; proc++)
1468 if (!cmdproc[proc].fp)
1469 break;
1470 if (proc >= MAXCMDS)
1471 return (0);
1472
1473 if (pipe(pio))
1474 return (0);
1475
1476 switch (cmdproc[proc].pid = fork()) {
1477 case -1:
1478 return (0);
1479 case 0:
1480 if (fp && fileno(fp) != usrfd) {
1481 (void) close(usrfd);
1482 if (dup2(fileno(fp), usrfd) != usrfd)
1483 _exit(CMDERR);
1484 (void) close(fileno(fp));
1485 }
1486 (void) close(cmdfd);
1487 if (dup2(pio[cmdfd], cmdfd) != cmdfd)
1488 _exit(CMDERR);
1489 (void) close(pio[cmdfd]);
1490 (void) close(pio[usrfd]);
1491 (void) execvp(cmd, argv);
1492 if (errno == ENOEXEC) {
1493 char **p;
1494 char **v;
1495
1496 /*
1497 * assume cmd is a shell script
1498 */
1499
1500 p = argv;
1501 while (*p++);
1502 if (v = (char **)malloc((p - argv + 1) *
1503 sizeof (char **))) {
1504 p = v;
1505 *p++ = cmd;
1506 if (*argv) argv++;
1507 while (*p++ = *argv++);
1508 (void) execv(getshell(), v);
1509 }
1510 }
1511 _exit(CMDERR);
1512 /*NOTREACHED*/
1513 default:
1514 (void) close(pio[cmdfd]);
1515 return (cmdproc[proc].fp = fdopen(pio[usrfd], mode));
1516 }
1517 }
1518
1519 /*
1520 * close a stream opened by cmdopen()
1521 * -1 returned if cmdopen() had a problem
1522 * otherwise exit() status of command is returned
1523 */
1524
1525 static int
1526 cmdclose(fp)
1527 FILE *fp;
1528 {
1529 int i;
1530 pid_t p, pid;
1531 int status;
1532
1533 for (i = 0; i < MAXCMDS; i++)
1534 if (fp == cmdproc[i].fp) break;
1535 if (i >= MAXCMDS)
1536 return (-1);
1537 (void) fclose(fp);
1538 cmdproc[i].fp = 0;
1539 pid = cmdproc[i].pid;
1540 while ((p = wait(&status)) != pid && p != (pid_t)-1);
1541 if (p == pid) {
1542 status = (status >> 8) & CMDERR;
1543 if (status == CMDERR)
1544 status = -1;
1545 }
1546 else
1547 status = -1;
1548 return (status);
1549 }
1550
1551 /*
1552 * return pointer to the full path name of the shell
1553 *
1554 * SHELL is read from the environment and must start with /
1555 *
1556 * if set-uid or set-gid then the executable and its containing
1557 * directory must not be writable by the real user
1558 *
1559 * /usr/bin/sh is returned by default
1560 */
1561
1562 char *
1563 getshell()
1564 {
1565 char *s;
1566 char *sh;
1567 uid_t u;
1568 int j;
1569
1570 if (((sh = getenv("SHELL")) != 0) && *sh == '/') {
1571 if (u = getuid()) {
1572 if ((u != geteuid() || getgid() != getegid()) &&
1573 access(sh, 2) == 0)
1574 goto defshell;
1575 s = strrchr(sh, '/');
1576 *s = 0;
1577 j = access(sh, 2);
1578 *s = '/';
1579 if (!j) goto defshell;
1580 }
1581 return (sh);
1582 }
1583 defshell:
1584 return ("/usr/bin/sh");
1585 }
1586
1587 /*
1588 * the following functions implement the added "-ls" option
1589 */
1590
1591 #include <utmpx.h>
1592 #include <sys/mkdev.h>
1593
1594 struct utmpx utmpx;
1595 #define NMAX (sizeof (utmpx.ut_name))
1596 #define SCPYN(a, b) (void) strncpy(a, b, NMAX)
1597
1598 #define NUID 64
1599 #define NGID 64
1600
1601 static struct ncache {
1602 int id;
1603 char name[NMAX+1];
1604 } nc[NUID], gc[NGID];
1605
1606 /*
1607 * This function assumes that the password file is hashed
1608 * (or some such) to allow fast access based on a name key.
1609 */
1610 static char *
1611 getname(uid_t uid)
1612 {
1613 struct passwd *pw;
1614 int cp;
1615
1616 #if (((NUID) & ((NUID) - 1)) != 0)
1617 cp = uid % (NUID);
1618 #else
1619 cp = uid & ((NUID) - 1);
1620 #endif
1621 if (nc[cp].id == uid && nc[cp].name[0])
1622 return (nc[cp].name);
1623 pw = getpwuid(uid);
1624 if (!pw)
1625 return (0);
1626 nc[cp].id = uid;
1627 SCPYN(nc[cp].name, pw->pw_name);
1628 return (nc[cp].name);
1629 }
1630
1631 /*
1632 * This function assumes that the group file is hashed
1633 * (or some such) to allow fast access based on a name key.
1634 */
1635 static char *
1636 getgroup(gid_t gid)
1637 {
1638 struct group *gr;
1639 int cp;
1640
1641 #if (((NGID) & ((NGID) - 1)) != 0)
1642 cp = gid % (NGID);
1643 #else
1644 cp = gid & ((NGID) - 1);
1645 #endif
1646 if (gc[cp].id == gid && gc[cp].name[0])
1647 return (gc[cp].name);
1648 gr = getgrgid(gid);
1649 if (!gr)
1650 return (0);
1651 gc[cp].id = gid;
1652 SCPYN(gc[cp].name, gr->gr_name);
1653 return (gc[cp].name);
1654 }
1655
1656 #define permoffset(who) ((who) * 3)
1657 #define permission(who, type) ((type) >> permoffset(who))
1658 #define kbytes(bytes) (((bytes) + 1023) / 1024)
1659
1660 static int
1661 list(file, stp)
1662 char *file;
1663 struct stat *stp;
1664 {
1665 char pmode[32], uname[32], gname[32], fsize[32], ftime[32];
1666 int trivial;
1667
1668 /*
1669 * Each line below contains the relevant permission (column 1) and character
1670 * shown when the corresponding execute bit is either clear (column 2)
1671 * or set (column 3)
1672 * These permissions are as shown by ls(1b)
1673 */
1674 static long special[] = { S_ISUID, 'S', 's',
1675 S_ISGID, 'S', 's',
1676 S_ISVTX, 'T', 't' };
1677
1678 static time_t sixmonthsago = -1;
1679 #ifdef S_IFLNK
1680 char flink[MAXPATHLEN + 1];
1681 #endif
1682 int who;
1683 char *cp;
1684 char *tailname;
1685 time_t now;
1686 long long ksize;
1687
1688 if (file == NULL || stp == NULL)
1689 return (-1);
1690
1691 (void) time(&now);
1692 if (sixmonthsago == -1)
1693 sixmonthsago = now - 6L*30L*24L*60L*60L;
1694
1695 switch (stp->st_mode & S_IFMT) {
1696 #ifdef S_IFDIR
1697 case S_IFDIR: /* directory */
1698 pmode[0] = 'd';
1699 break;
1700 #endif
1701 #ifdef S_IFCHR
1702 case S_IFCHR: /* character special */
1703 pmode[0] = 'c';
1704 break;
1705 #endif
1706 #ifdef S_IFBLK
1707 case S_IFBLK: /* block special */
1708 pmode[0] = 'b';
1709 break;
1710 #endif
1711 #ifdef S_IFIFO
1712 case S_IFIFO: /* fifo special */
1713 pmode[0] = 'p';
1714 break;
1715 #endif
1716 #ifdef S_IFLNK
1717 case S_IFLNK: /* symbolic link */
1718 pmode[0] = 'l';
1719 break;
1720 #endif
1721 #ifdef S_IFSOCK
1722 case S_IFSOCK: /* socket */
1723 pmode[0] = 's';
1724 break;
1725 #endif
1726 #ifdef S_IFDOOR
1727 case S_IFDOOR: /* door */
1728 pmode[0] = 'D';
1729 break;
1730 #endif
1731 #ifdef S_IFREG
1732 case S_IFREG: /* regular */
1733 pmode[0] = '-';
1734 break;
1735 #endif
1736 default:
1737 pmode[0] = '?';
1738 break;
1739 }
1740
1741 for (who = 0; who < 3; who++) {
1742 int is_exec = stp->st_mode & permission(who, S_IEXEC)? 1 : 0;
1743
1744 if (stp->st_mode & permission(who, S_IREAD))
1745 pmode[permoffset(who) + 1] = 'r';
1746 else
1747 pmode[permoffset(who) + 1] = '-';
1748
1749 if (stp->st_mode & permission(who, S_IWRITE))
1750 pmode[permoffset(who) + 2] = 'w';
1751 else
1752 pmode[permoffset(who) + 2] = '-';
1753
1754 if (stp->st_mode & special[who * 3])
1755 pmode[permoffset(who) + 3] =
1756 special[who * 3 + 1 + is_exec];
1757 else if (is_exec)
1758 pmode[permoffset(who) + 3] = 'x';
1759 else
1760 pmode[permoffset(who) + 3] = '-';
1761 }
1762
1763 /*
1764 * Need to get the tail of the file name, since we have
1765 * already chdir()ed into the directory of the file
1766 */
1767
1768 tailname = gettail(file);
1769
1770 trivial = acl_trivial(tailname);
1771 if (trivial == -1)
1772 trivial = 0;
1773
1774 if (trivial == 1)
1775 pmode[permoffset(who) + 1] = '+';
1776 else
1777 pmode[permoffset(who) + 1] = ' ';
1778
1779 pmode[permoffset(who) + 2] = '\0';
1780
1781 /*
1782 * Prepare uname and gname. Always add a space afterwards
1783 * to keep columns from running together.
1784 */
1785 cp = getname(stp->st_uid);
1786 if (cp != NULL)
1787 (void) sprintf(uname, "%-8s ", cp);
1788 else
1789 (void) sprintf(uname, "%-8u ", stp->st_uid);
1790
1791 cp = getgroup(stp->st_gid);
1792 if (cp != NULL)
1793 (void) sprintf(gname, "%-8s ", cp);
1794 else
1795 (void) sprintf(gname, "%-8u ", stp->st_gid);
1796
1797 if (pmode[0] == 'b' || pmode[0] == 'c')
1798 (void) sprintf(fsize, "%3ld,%4ld",
1799 major(stp->st_rdev), minor(stp->st_rdev));
1800 else {
1801 (void) sprintf(fsize, (stp->st_size < 100000000) ?
1802 "%8lld" : "%lld", stp->st_size);
1803 #ifdef S_IFLNK
1804 if (pmode[0] == 'l') {
1805
1806
1807 who = readlink(tailname, flink, sizeof (flink) - 1);
1808
1809 if (who >= 0)
1810 flink[who] = '\0';
1811 else
1812 flink[0] = '\0';
1813 }
1814 #endif
1815 }
1816
1817 cp = ctime(&stp->st_mtime);
1818 if (stp->st_mtime < sixmonthsago || stp->st_mtime > now)
1819 (void) sprintf(ftime, "%-7.7s %-4.4s", cp + 4, cp + 20);
1820 else
1821 (void) sprintf(ftime, "%-12.12s", cp + 4);
1822
1823 (void) printf((stp->st_ino < 100000) ? "%5llu " :
1824 "%llu ", stp->st_ino); /* inode # */
1825 #ifdef S_IFSOCK
1826 ksize = (long long) kbytes(ldbtob(stp->st_blocks)); /* kbytes */
1827 #else
1828 ksize = (long long) kbytes(stp->st_size); /* kbytes */
1829 #endif
1830 (void) printf((ksize < 10000) ? "%4lld " : "%lld ", ksize);
1831 (void) printf("%s %2ld %s%s%s %s %s%s%s\n",
1832 pmode, /* protection */
1833 stp->st_nlink, /* # of links */
1834 uname, /* owner */
1835 gname, /* group */
1836 fsize, /* # of bytes */
1837 ftime, /* modify time */
1838 file, /* name */
1839 #ifdef S_IFLNK
1840 (pmode[0] == 'l') ? " -> " : "",
1841 (pmode[0] == 'l') ? flink : "" /* symlink */
1842 #else
1843 "",
1844 ""
1845 #endif
1846 );
1847
1848 return (0);
1849 }
1850
1851 static char *
1852 new_string(char *s)
1853 {
1854 char *p = strdup(s);
1855
1856 if (p)
1857 return (p);
1858 (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname);
1859 exit(1);
1860 /*NOTREACHED*/
1861 }
1862
1863 /*
1864 * Read remote file system types from REMOTE_FS into the
1865 * remote_fstypes array.
1866 */
1867 static void
1868 init_remote_fs()
1869 {
1870 FILE *fp;
1871 char line_buf[LINEBUF_SIZE];
1872
1873 if ((fp = fopen(REMOTE_FS, "r")) == NULL) {
1874 (void) fprintf(stderr,
1875 gettext("%s: Warning: can't open %s, ignored\n"),
1876 REMOTE_FS, cmdname);
1877 /* Use default string name for NFS */
1878 remote_fstypes[fstype_index++] = "nfs";
1879 return;
1880 }
1881
1882 while (fgets(line_buf, sizeof (line_buf), fp) != NULL) {
1883 char buf[LINEBUF_SIZE];
1884
1885 /* LINTED - unbounded string specifier */
1886 (void) sscanf(line_buf, "%s", buf);
1887 remote_fstypes[fstype_index++] = new_string(buf);
1888
1889 if (fstype_index == N_FSTYPES)
1890 break;
1891 }
1892 (void) fclose(fp);
1893 }
1894
1895 #define NPERM 30 /* Largest machine */
1896
1897 /*
1898 * The PERM struct is the machine that builds permissions. The p_special
1899 * field contains what permissions need to be checked at run-time in
1900 * getmode(). This is one of 'X', 'u', 'g', or 'o'. It contains '\0' to
1901 * indicate normal processing.
1902 */
1903 typedef struct PERMST {
1904 ushort_t p_who; /* Range of permission (e.g. ugo) */
1905 ushort_t p_perm; /* Bits to turn on, off, assign */
1906 uchar_t p_op; /* Operation: + - = */
1907 uchar_t p_special; /* Special handling? */
1908 } PERMST;
1909
1910 #ifndef S_ISVTX
1911 #define S_ISVTX 0 /* Not .1 */
1912 #endif
1913
1914 /* Mask values */
1915 #define P_A (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO) /* allbits */
1916 #define P_U (S_ISUID|S_ISVTX|S_IRWXU) /* user */
1917 #define P_G (S_ISGID|S_ISVTX|S_IRWXG) /* group */
1918 #define P_O (S_ISVTX|S_IRWXO) /* other */
1919
1920 static int iswho(int c);
1921 static int isop(int c);
1922 static int isperm(PERMST *pp, int c);
1923
1924 static PERMST machine[NPERM]; /* Permission construction machine */
1925 static PERMST *endp; /* Last used PERM structure */
1926
1927 static uint_t nowho; /* No who for this mode (DOS kludge) */
1928
1929 /*
1930 * Read an ASCII string containing the symbolic/octal mode and
1931 * compile an automaton that recognizes it. The return value
1932 * is NULL if everything is OK, otherwise it is -1.
1933 */
1934 static int
1935 readmode(ascmode)
1936 const char *ascmode;
1937 {
1938 const char *amode = ascmode;
1939 PERMST *pp;
1940 int seen_X;
1941
1942 nowho = 0;
1943 seen_X = 0;
1944 pp = &machine[0];
1945 if (*amode >= '0' && *amode <= '7') {
1946 int mode;
1947
1948 mode = 0;
1949 while (*amode >= '0' && *amode <= '7')
1950 mode = (mode<<3) + *amode++ - '0';
1951 if (*amode != '\0')
1952 return (-1);
1953 #if S_ISUID != 04000 || S_ISGID != 02000 || \
1954 S_IRUSR != 0400 || S_IWUSR != 0200 || S_IXUSR != 0100 || \
1955 S_IRGRP != 0040 || S_IWGRP != 0020 || S_IXGRP != 0010 || \
1956 S_IROTH != 0004 || S_IWOTH != 0002 || S_IXOTH != 0001
1957 /*
1958 * There is no requirement of the octal mode bits being
1959 * the same as the S_ macros.
1960 */
1961 {
1962 mode_t mapping[] = {
1963 S_IXOTH, S_IWOTH, S_IROTH,
1964 S_IXGRP, S_IWGRP, S_IRGRP,
1965 S_IXUSR, S_IWUSR, S_IRUSR,
1966 S_ISGID, S_ISUID,
1967 0
1968 };
1969 int i, newmode = 0;
1970
1971 for (i = 0; mapping[i] != 0; i++)
1972 if (mode & (1<<i))
1973 newmode |= mapping[i];
1974 mode = newmode;
1975 }
1976 #endif
1977 pp->p_who = P_A;
1978 pp->p_perm = mode;
1979 pp->p_op = '=';
1980 } else for (;;) {
1981 int t;
1982 int who = 0;
1983
1984 while ((t = iswho(*amode)) != 0) {
1985 ++amode;
1986 who |= t;
1987 }
1988 if (who == 0) {
1989 mode_t currmask;
1990 (void) umask(currmask = umask((mode_t)0));
1991
1992 /*
1993 * If no who specified, must use contents of
1994 * umask to determine which bits to flip. This
1995 * is POSIX/V7/BSD behaviour, but not SVID.
1996 */
1997 who = (~currmask)&P_A;
1998 ++nowho;
1999 } else
2000 nowho = 0;
2001 samewho:
2002 if (!isop(pp->p_op = *amode++))
2003 return (-1);
2004 pp->p_perm = 0;
2005 pp->p_special = 0;
2006 while ((t = isperm(pp, *amode)) != 0) {
2007 if (pp->p_special == 'X') {
2008 seen_X = 1;
2009
2010 if (pp->p_perm != 0) {
2011 ushort_t op;
2012
2013 /*
2014 * Remember the 'who' for the previous
2015 * transformation.
2016 */
2017 pp->p_who = who;
2018 pp->p_special = 0;
2019
2020 op = pp->p_op;
2021
2022 /* Keep 'X' separate */
2023 ++pp;
2024 pp->p_special = 'X';
2025 pp->p_op = op;
2026 }
2027 } else if (seen_X) {
2028 ushort_t op;
2029
2030 /* Remember the 'who' for the X */
2031 pp->p_who = who;
2032
2033 op = pp->p_op;
2034
2035 /* Keep 'X' separate */
2036 ++pp;
2037 pp->p_perm = 0;
2038 pp->p_special = 0;
2039 pp->p_op = op;
2040 }
2041 ++amode;
2042 pp->p_perm |= t;
2043 }
2044
2045 /*
2046 * These returned 0, but were actually parsed, so
2047 * don't look at them again.
2048 */
2049 switch (pp->p_special) {
2050 case 'u':
2051 case 'g':
2052 case 'o':
2053 ++amode;
2054 break;
2055 }
2056 pp->p_who = who;
2057 switch (*amode) {
2058 case '\0':
2059 break;
2060
2061 case ',':
2062 ++amode;
2063 ++pp;
2064 continue;
2065
2066 default:
2067 ++pp;
2068 goto samewho;
2069 }
2070 break;
2071 }
2072 endp = pp;
2073 return (NULL);
2074 }
2075
2076 /*
2077 * Given a character from the mode, return the associated
2078 * value as who (user designation) mask or 0 if this isn't valid.
2079 */
2080 static int
2081 iswho(c)
2082 int c;
2083 {
2084 switch (c) {
2085 case 'a':
2086 return (P_A);
2087
2088 case 'u':
2089 return (P_U);
2090
2091 case 'g':
2092 return (P_G);
2093
2094 case 'o':
2095 return (P_O);
2096
2097 default:
2098 return (0);
2099 }
2100 /* NOTREACHED */
2101 }
2102
2103 /*
2104 * Return non-zero if this is a valid op code
2105 * in a symbolic mode.
2106 */
2107 static int
2108 isop(c)
2109 int c;
2110 {
2111 switch (c) {
2112 case '+':
2113 case '-':
2114 case '=':
2115 return (1);
2116
2117 default:
2118 return (0);
2119 }
2120 /* NOTREACHED */
2121 }
2122
2123 /*
2124 * Return the permission bits implied by this character or 0
2125 * if it isn't valid. Also returns 0 when the pseudo-permissions 'u', 'g', or
2126 * 'o' are used, and sets pp->p_special to the one used.
2127 */
2128 static int
2129 isperm(pp, c)
2130 PERMST *pp;
2131 int c;
2132 {
2133 switch (c) {
2134 case 'u':
2135 case 'g':
2136 case 'o':
2137 pp->p_special = c;
2138 return (0);
2139
2140 case 'r':
2141 return (S_IRUSR|S_IRGRP|S_IROTH);
2142
2143 case 'w':
2144 return (S_IWUSR|S_IWGRP|S_IWOTH);
2145
2146 case 'x':
2147 return (S_IXUSR|S_IXGRP|S_IXOTH);
2148
2149 #if S_ISVTX != 0
2150 case 't':
2151 return (S_ISVTX);
2152 #endif
2153
2154 case 'X':
2155 pp->p_special = 'X';
2156 return (S_IXUSR|S_IXGRP|S_IXOTH);
2157
2158 #if S_ISVTX != 0
2159 case 'a':
2160 return (S_ISVTX);
2161 #endif
2162
2163 case 'h':
2164 return (S_ISUID);
2165
2166 /*
2167 * This change makes:
2168 * chmod +s file
2169 * set the system bit on dos but means that
2170 * chmod u+s file
2171 * chmod g+s file
2172 * chmod a+s file
2173 * are all like UNIX.
2174 */
2175 case 's':
2176 return (nowho ? S_ISGID : S_ISGID|S_ISUID);
2177
2178 default:
2179 return (0);
2180 }
2181 /* NOTREACHED */
2182 }
2183
2184 /*
2185 * Execute the automaton that is created by readmode()
2186 * to generate the final mode that will be used. This
2187 * code is passed a starting mode that is usually the original
2188 * mode of the file being changed (or 0). Note that this mode must contain
2189 * the file-type bits as well, so that S_ISDIR will succeed on directories.
2190 */
2191 static mode_t
2192 getmode(mode_t startmode)
2193 {
2194 PERMST *pp;
2195 mode_t temp;
2196 mode_t perm;
2197
2198 for (pp = &machine[0]; pp <= endp; ++pp) {
2199 perm = (mode_t)0;
2200 /*
2201 * For the special modes 'u', 'g' and 'o', the named portion
2202 * of the mode refers to after the previous clause has been
2203 * processed, while the 'X' mode refers to the contents of the
2204 * mode before any clauses have been processed.
2205 *
2206 * References: P1003.2/D11.2, Section 4.7.7,
2207 * lines 2568-2570, 2578-2583
2208 */
2209 switch (pp->p_special) {
2210 case 'u':
2211 temp = startmode & S_IRWXU;
2212 if (temp & (S_IRUSR|S_IRGRP|S_IROTH))
2213 perm |= ((S_IRUSR|S_IRGRP|S_IROTH) &
2214 pp->p_who);
2215 if (temp & (S_IWUSR|S_IWGRP|S_IWOTH))
2216 perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who);
2217 if (temp & (S_IXUSR|S_IXGRP|S_IXOTH))
2218 perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who);
2219 break;
2220
2221 case 'g':
2222 temp = startmode & S_IRWXG;
2223 if (temp & (S_IRUSR|S_IRGRP|S_IROTH))
2224 perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & pp->p_who);
2225 if (temp & (S_IWUSR|S_IWGRP|S_IWOTH))
2226 perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who);
2227 if (temp & (S_IXUSR|S_IXGRP|S_IXOTH))
2228 perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who);
2229 break;
2230
2231 case 'o':
2232 temp = startmode & S_IRWXO;
2233 if (temp & (S_IRUSR|S_IRGRP|S_IROTH))
2234 perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & pp->p_who);
2235 if (temp & (S_IWUSR|S_IWGRP|S_IWOTH))
2236 perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who);
2237 if (temp & (S_IXUSR|S_IXGRP|S_IXOTH))
2238 perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who);
2239 break;
2240
2241 case 'X':
2242 perm = pp->p_perm;
2243 break;
2244
2245 default:
2246 perm = pp->p_perm;
2247 break;
2248 }
2249 switch (pp->p_op) {
2250 case '-':
2251 startmode &= ~(perm & pp->p_who);
2252 break;
2253
2254 case '=':
2255 startmode &= ~pp->p_who;
2256 /* FALLTHROUGH */
2257 case '+':
2258 startmode |= (perm & pp->p_who);
2259 break;
2260 }
2261 }
2262 return (startmode);
2263 }
2264
2265 /*
2266 * Returns the last component of a path name, unless it is
2267 * an absolute path, in which case it returns the whole path
2268 */
2269 static char
2270 *gettail(char *fname)
2271 {
2272 char *base = fname;
2273
2274 if (*fname != '/') {
2275 if ((base = strrchr(fname, '/')) != NULL)
2276 base++;
2277 else
2278 base = fname;
2279 }
2280 return (base);
2281 }