17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5*d35170d6Srm * Common Development and Distribution License (the "License"). 6*d35170d6Srm * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*d35170d6Srm * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 26da1a9cbeSjonb #pragma ident "%Z%%M% %I% %E% SMI" 27da1a9cbeSjonb 287c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 297c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate /* Parts of this product may be derived from */ 337c478bd9Sstevel@tonic-gate /* Mortice Kern Systems Inc. and Berkeley 4.3 BSD systems. */ 347c478bd9Sstevel@tonic-gate /* licensed from Mortice Kern Systems Inc. and */ 357c478bd9Sstevel@tonic-gate /* the University of California. */ 367c478bd9Sstevel@tonic-gate 377c478bd9Sstevel@tonic-gate /* 387c478bd9Sstevel@tonic-gate * Copyright 1985, 1990 by Mortice Kern Systems Inc. All rights reserved. 397c478bd9Sstevel@tonic-gate */ 407c478bd9Sstevel@tonic-gate 417c478bd9Sstevel@tonic-gate #include <stdio.h> 427c478bd9Sstevel@tonic-gate #include <errno.h> 437c478bd9Sstevel@tonic-gate #include <pwd.h> 447c478bd9Sstevel@tonic-gate #include <grp.h> 457c478bd9Sstevel@tonic-gate #include <sys/types.h> 467c478bd9Sstevel@tonic-gate #include <sys/stat.h> 477c478bd9Sstevel@tonic-gate #include <sys/param.h> 487c478bd9Sstevel@tonic-gate #include <sys/acl.h> 497c478bd9Sstevel@tonic-gate #include <limits.h> 507c478bd9Sstevel@tonic-gate #include <unistd.h> 517c478bd9Sstevel@tonic-gate #include <stdlib.h> 527c478bd9Sstevel@tonic-gate #include <locale.h> 537c478bd9Sstevel@tonic-gate #include <string.h> 547c478bd9Sstevel@tonic-gate #include <strings.h> 557c478bd9Sstevel@tonic-gate #include <libgen.h> 567c478bd9Sstevel@tonic-gate #include <ctype.h> 577c478bd9Sstevel@tonic-gate #include <wait.h> 587c478bd9Sstevel@tonic-gate #include <fnmatch.h> 597c478bd9Sstevel@tonic-gate #include <langinfo.h> 607c478bd9Sstevel@tonic-gate #include <ftw.h> 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate #define A_DAY (long)(60*60*24) /* a day full of seconds */ 63da1a9cbeSjonb #define A_MIN (long)(60) 647c478bd9Sstevel@tonic-gate #define BLKSIZ 512 657c478bd9Sstevel@tonic-gate #define round(x, s) (((x)+(s)-1)&~((s)-1)) 667c478bd9Sstevel@tonic-gate #ifndef FTW_SLN 677c478bd9Sstevel@tonic-gate #define FTW_SLN 7 687c478bd9Sstevel@tonic-gate #endif 697c478bd9Sstevel@tonic-gate #define LINEBUF_SIZE LINE_MAX /* input or output lines */ 707c478bd9Sstevel@tonic-gate #define REMOTE_FS "/etc/dfs/fstypes" 717c478bd9Sstevel@tonic-gate #define N_FSTYPES 20 72*d35170d6Srm #define SHELL_MAXARGS 253 /* see doexec() for description */ 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate /* 757c478bd9Sstevel@tonic-gate * This is the list of operations 767c478bd9Sstevel@tonic-gate * F_USER and F_GROUP are named to avoid conflict with USER and GROUP defined 777c478bd9Sstevel@tonic-gate * in sys/acl.h 787c478bd9Sstevel@tonic-gate */ 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate enum Command 817c478bd9Sstevel@tonic-gate { 827c478bd9Sstevel@tonic-gate PRINT, DEPTH, LOCAL, MOUNT, ATIME, MTIME, CTIME, NEWER, 837c478bd9Sstevel@tonic-gate NAME, F_USER, F_GROUP, INUM, SIZE, LINKS, PERM, EXEC, OK, CPIO, NCPIO, 847c478bd9Sstevel@tonic-gate TYPE, AND, OR, NOT, LPAREN, RPAREN, CSIZE, VARARGS, FOLLOW, 85da1a9cbeSjonb PRUNE, NOUSER, NOGRP, FSTYPE, LS, XATTR, ACL, MMIN, AMIN, CMIN 867c478bd9Sstevel@tonic-gate }; 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate enum Type 897c478bd9Sstevel@tonic-gate { 907c478bd9Sstevel@tonic-gate Unary, Id, Num, Str, Exec, Cpio, Op 917c478bd9Sstevel@tonic-gate }; 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate struct Args 947c478bd9Sstevel@tonic-gate { 957c478bd9Sstevel@tonic-gate char name[10]; 967c478bd9Sstevel@tonic-gate enum Command action; 977c478bd9Sstevel@tonic-gate enum Type type; 987c478bd9Sstevel@tonic-gate }; 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate /* 1017c478bd9Sstevel@tonic-gate * Except for pathnames, these are the only legal arguments 1027c478bd9Sstevel@tonic-gate */ 1037c478bd9Sstevel@tonic-gate static struct Args commands[] = 1047c478bd9Sstevel@tonic-gate { 1057c478bd9Sstevel@tonic-gate "!", NOT, Op, 1067c478bd9Sstevel@tonic-gate "(", LPAREN, Unary, 1077c478bd9Sstevel@tonic-gate ")", RPAREN, Unary, 1087c478bd9Sstevel@tonic-gate "-a", AND, Op, 109da1a9cbeSjonb "-amin", AMIN, Num, 1107c478bd9Sstevel@tonic-gate "-atime", ATIME, Num, 1117c478bd9Sstevel@tonic-gate "-cpio", CPIO, Cpio, 112da1a9cbeSjonb "-cmin", CMIN, Num, 1137c478bd9Sstevel@tonic-gate "-ctime", CTIME, Num, 1147c478bd9Sstevel@tonic-gate "-depth", DEPTH, Unary, 1157c478bd9Sstevel@tonic-gate "-exec", EXEC, Exec, 1167c478bd9Sstevel@tonic-gate "-follow", FOLLOW, Unary, 1177c478bd9Sstevel@tonic-gate "-group", F_GROUP, Num, 1187c478bd9Sstevel@tonic-gate "-inum", INUM, Num, 1197c478bd9Sstevel@tonic-gate "-links", LINKS, Num, 1207c478bd9Sstevel@tonic-gate "-local", LOCAL, Unary, 1217c478bd9Sstevel@tonic-gate "-mount", MOUNT, Unary, 122da1a9cbeSjonb "-mmin", MMIN, Num, 1237c478bd9Sstevel@tonic-gate "-mtime", MTIME, Num, 1247c478bd9Sstevel@tonic-gate "-name", NAME, Str, 1257c478bd9Sstevel@tonic-gate "-ncpio", NCPIO, Cpio, 1267c478bd9Sstevel@tonic-gate "-newer", NEWER, Str, 1277c478bd9Sstevel@tonic-gate "-o", OR, Op, 1287c478bd9Sstevel@tonic-gate "-ok", OK, Exec, 1297c478bd9Sstevel@tonic-gate "-perm", PERM, Num, 1307c478bd9Sstevel@tonic-gate "-print", PRINT, Unary, 1317c478bd9Sstevel@tonic-gate "-size", SIZE, Num, 1327c478bd9Sstevel@tonic-gate "-type", TYPE, Num, 1337c478bd9Sstevel@tonic-gate "-xdev", MOUNT, Unary, 1347c478bd9Sstevel@tonic-gate "-user", F_USER, Num, 1357c478bd9Sstevel@tonic-gate "-prune", PRUNE, Unary, 1367c478bd9Sstevel@tonic-gate "-nouser", NOUSER, Unary, 1377c478bd9Sstevel@tonic-gate "-nogroup", NOGRP, Unary, 1387c478bd9Sstevel@tonic-gate "-fstype", FSTYPE, Str, 1397c478bd9Sstevel@tonic-gate "-ls", LS, Unary, 1407c478bd9Sstevel@tonic-gate "-xattr", XATTR, Unary, 1417c478bd9Sstevel@tonic-gate "-acl", ACL, Unary, 1427c478bd9Sstevel@tonic-gate NULL, 0, 0 1437c478bd9Sstevel@tonic-gate }; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate union Item 1467c478bd9Sstevel@tonic-gate { 1477c478bd9Sstevel@tonic-gate struct Node *np; 1487c478bd9Sstevel@tonic-gate struct Arglist *vp; 1497c478bd9Sstevel@tonic-gate time_t t; 1507c478bd9Sstevel@tonic-gate char *cp; 1517c478bd9Sstevel@tonic-gate char **ap; 1527c478bd9Sstevel@tonic-gate long l; 1537c478bd9Sstevel@tonic-gate int i; 1547c478bd9Sstevel@tonic-gate long long ll; 1557c478bd9Sstevel@tonic-gate }; 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate struct Node 1587c478bd9Sstevel@tonic-gate { 1597c478bd9Sstevel@tonic-gate struct Node *next; 1607c478bd9Sstevel@tonic-gate enum Command action; 1617c478bd9Sstevel@tonic-gate enum Type type; 1627c478bd9Sstevel@tonic-gate union Item first; 1637c478bd9Sstevel@tonic-gate union Item second; 1647c478bd9Sstevel@tonic-gate }; 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate /* if no -print, -exec or -ok replace "expression" with "(expression) -print" */ 1677c478bd9Sstevel@tonic-gate static struct Node PRINT_NODE = { 0, PRINT, 0, 0}; 1687c478bd9Sstevel@tonic-gate static struct Node LPAREN_NODE = { 0, LPAREN, 0, 0}; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate /* 1727c478bd9Sstevel@tonic-gate * Prototype variable size arglist buffer 1737c478bd9Sstevel@tonic-gate */ 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate struct Arglist 1767c478bd9Sstevel@tonic-gate { 1777c478bd9Sstevel@tonic-gate struct Arglist *next; 1787c478bd9Sstevel@tonic-gate char *end; 1797c478bd9Sstevel@tonic-gate char *nextstr; 1807c478bd9Sstevel@tonic-gate char **firstvar; 1817c478bd9Sstevel@tonic-gate char **nextvar; 1827c478bd9Sstevel@tonic-gate char *arglist[1]; 1837c478bd9Sstevel@tonic-gate }; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate static int compile(); 1877c478bd9Sstevel@tonic-gate static int execute(); 188*d35170d6Srm static int doexec(char *, char **, int *); 1897c478bd9Sstevel@tonic-gate static struct Args *lookup(); 1907c478bd9Sstevel@tonic-gate static int ok(); 1916c83d09fSrobbin static void usage(void) __NORETURN; 1927c478bd9Sstevel@tonic-gate static struct Arglist *varargs(); 1937c478bd9Sstevel@tonic-gate static int list(); 1947c478bd9Sstevel@tonic-gate static char *getgroup(); 1957c478bd9Sstevel@tonic-gate static FILE *cmdopen(); 1967c478bd9Sstevel@tonic-gate static int cmdclose(); 1977c478bd9Sstevel@tonic-gate static char *getshell(); 1987c478bd9Sstevel@tonic-gate static void init_remote_fs(); 1997c478bd9Sstevel@tonic-gate static char *getname(); 2007c478bd9Sstevel@tonic-gate static int readmode(); 2017c478bd9Sstevel@tonic-gate static mode_t getmode(); 2027c478bd9Sstevel@tonic-gate static char *gettail(); 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate static int walkflags = FTW_CHDIR|FTW_PHYS|FTW_ANYERR; 2067c478bd9Sstevel@tonic-gate static struct Node *savetnode; 2077c478bd9Sstevel@tonic-gate static struct Node *topnode; 2087c478bd9Sstevel@tonic-gate static struct Node *freenode; /* next free node we may use later */ 2097c478bd9Sstevel@tonic-gate static char *cpio[] = { "cpio", "-o", 0 }; 2107c478bd9Sstevel@tonic-gate static char *ncpio[] = { "cpio", "-oc", 0 }; 2117c478bd9Sstevel@tonic-gate static char *cpiol[] = { "cpio", "-oL", 0 }; 2127c478bd9Sstevel@tonic-gate static char *ncpiol[] = { "cpio", "-ocL", 0 }; 2137c478bd9Sstevel@tonic-gate static time_t now; 2147c478bd9Sstevel@tonic-gate static FILE *output; 2157c478bd9Sstevel@tonic-gate static char *dummyarg = (char *)-1; 2167c478bd9Sstevel@tonic-gate static int lastval; 2177c478bd9Sstevel@tonic-gate static int varsize; 2187c478bd9Sstevel@tonic-gate static struct Arglist *lastlist; 2197c478bd9Sstevel@tonic-gate static char *cmdname; 2207c478bd9Sstevel@tonic-gate static char *remote_fstypes[N_FSTYPES+1]; 2217c478bd9Sstevel@tonic-gate static int fstype_index = 0; 2227c478bd9Sstevel@tonic-gate static int action_expression = 0; /* -print, -exec, or -ok */ 2237c478bd9Sstevel@tonic-gate static int error = 0; 2247c478bd9Sstevel@tonic-gate static int paren_cnt = 0; /* keeps track of parentheses */ 2257c478bd9Sstevel@tonic-gate static int hflag = 0; 2267c478bd9Sstevel@tonic-gate static int lflag = 0; 227*d35170d6Srm /* set when doexec()-invoked utility returns non-zero */ 228*d35170d6Srm static int exec_exitcode = 0; 2297c478bd9Sstevel@tonic-gate extern char **environ; 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate int 2327c478bd9Sstevel@tonic-gate main(int argc, char **argv) 2337c478bd9Sstevel@tonic-gate { 2347c478bd9Sstevel@tonic-gate char *cp; 2357c478bd9Sstevel@tonic-gate int c; 2367c478bd9Sstevel@tonic-gate int paths; 2377c478bd9Sstevel@tonic-gate char *cwdpath; 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 2407c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 2417c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 2427c478bd9Sstevel@tonic-gate #endif 2437c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate cmdname = argv[0]; 2467c478bd9Sstevel@tonic-gate if (time(&now) == (time_t)(-1)) { 2477c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: time() %s\n"), 2487c478bd9Sstevel@tonic-gate cmdname, strerror(errno)); 2497c478bd9Sstevel@tonic-gate exit(1); 2507c478bd9Sstevel@tonic-gate } 2517c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "HL")) != -1) { 2527c478bd9Sstevel@tonic-gate switch (c) { 2537c478bd9Sstevel@tonic-gate case 'H': 2547c478bd9Sstevel@tonic-gate hflag = 1; 2557c478bd9Sstevel@tonic-gate lflag = 0; 2567c478bd9Sstevel@tonic-gate break; 2577c478bd9Sstevel@tonic-gate case 'L': 2587c478bd9Sstevel@tonic-gate hflag = 0; 2597c478bd9Sstevel@tonic-gate lflag = 1; 2607c478bd9Sstevel@tonic-gate break; 2617c478bd9Sstevel@tonic-gate case '?': 2627c478bd9Sstevel@tonic-gate usage(); 2637c478bd9Sstevel@tonic-gate break; 2647c478bd9Sstevel@tonic-gate } 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate argc -= optind; 2687c478bd9Sstevel@tonic-gate argv += optind; 2697c478bd9Sstevel@tonic-gate 2707c478bd9Sstevel@tonic-gate if (argc < 1) { 2717c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 2727c478bd9Sstevel@tonic-gate gettext("%s: insufficient number of arguments\n"), cmdname); 2737c478bd9Sstevel@tonic-gate usage(); 2747c478bd9Sstevel@tonic-gate } 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate for (paths = 0; (cp = argv[paths]) != 0; ++paths) { 2777c478bd9Sstevel@tonic-gate if (*cp == '-') 2787c478bd9Sstevel@tonic-gate break; 2797c478bd9Sstevel@tonic-gate else if ((*cp == '!' || *cp == '(') && *(cp+1) == 0) 2807c478bd9Sstevel@tonic-gate break; 2817c478bd9Sstevel@tonic-gate } 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate if (paths == 0) /* no path-list */ 2847c478bd9Sstevel@tonic-gate usage(); 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate output = stdout; 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate /* lflag is the same as -follow */ 2897c478bd9Sstevel@tonic-gate if (lflag) 2907c478bd9Sstevel@tonic-gate walkflags &= ~FTW_PHYS; 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate /* allocate enough space for the compiler */ 2937c478bd9Sstevel@tonic-gate topnode = malloc((argc + 1) * sizeof (struct Node)); 2947c478bd9Sstevel@tonic-gate savetnode = malloc((argc + 1) * sizeof (struct Node)); 2957c478bd9Sstevel@tonic-gate (void) memset(topnode, 0, (argc + 1) * sizeof (struct Node)); 2967c478bd9Sstevel@tonic-gate (void) memset(savetnode, 0, (argc + 1) * sizeof (struct Node)); 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate if (compile(argv + paths, topnode, &action_expression) == 0) { 2997c478bd9Sstevel@tonic-gate /* no expression, default to -print */ 3007c478bd9Sstevel@tonic-gate (void) memcpy(topnode, &PRINT_NODE, sizeof (struct Node)); 3017c478bd9Sstevel@tonic-gate } else if (!action_expression) { 3027c478bd9Sstevel@tonic-gate /* 3037c478bd9Sstevel@tonic-gate * if no action expression, insert an LPAREN node above topnode, 3047c478bd9Sstevel@tonic-gate * with a PRINT node as its next node 3057c478bd9Sstevel@tonic-gate */ 3067c478bd9Sstevel@tonic-gate struct Node *savenode; 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate if (freenode == NULL) { 3097c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: can't append -print" 3107c478bd9Sstevel@tonic-gate " implicitly; try explicit -print option\n"), 3117c478bd9Sstevel@tonic-gate cmdname); 3127c478bd9Sstevel@tonic-gate exit(1); 3137c478bd9Sstevel@tonic-gate } 3147c478bd9Sstevel@tonic-gate savenode = topnode; 3157c478bd9Sstevel@tonic-gate topnode = freenode++; 3167c478bd9Sstevel@tonic-gate (void) memcpy(topnode, &LPAREN_NODE, sizeof (struct Node)); 3177c478bd9Sstevel@tonic-gate topnode->next = freenode; 3187c478bd9Sstevel@tonic-gate topnode->first.np = savenode; 3197c478bd9Sstevel@tonic-gate (void) memcpy(topnode->next, &PRINT_NODE, sizeof (struct Node)); 3207c478bd9Sstevel@tonic-gate } 3217c478bd9Sstevel@tonic-gate (void) memcpy(savetnode, topnode, ((argc + 1) * sizeof (struct Node))); 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate while (paths--) { 3247c478bd9Sstevel@tonic-gate char *curpath; 3257c478bd9Sstevel@tonic-gate struct stat sb; 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate curpath = *(argv++); 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3307c478bd9Sstevel@tonic-gate * If -H is specified, it means we walk the first 3317c478bd9Sstevel@tonic-gate * level (pathname on command line) logically, following 3327c478bd9Sstevel@tonic-gate * symlinks, but lower levels are walked physically. 3337c478bd9Sstevel@tonic-gate * We use our own secret interface to nftw() to change 3347c478bd9Sstevel@tonic-gate * the from stat to lstat after the top level is walked. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate if (hflag) { 3377c478bd9Sstevel@tonic-gate if (stat(curpath, &sb) < 0 && errno == ENOENT) 3387c478bd9Sstevel@tonic-gate walkflags &= ~FTW_HOPTION; 3397c478bd9Sstevel@tonic-gate else 3407c478bd9Sstevel@tonic-gate walkflags |= FTW_HOPTION; 3417c478bd9Sstevel@tonic-gate } 3427c478bd9Sstevel@tonic-gate 3437c478bd9Sstevel@tonic-gate /* 3447c478bd9Sstevel@tonic-gate * We need this check as nftw needs a CWD and we have no 3457c478bd9Sstevel@tonic-gate * way of returning back from that code with a meaningful 3467c478bd9Sstevel@tonic-gate * error related to this 3477c478bd9Sstevel@tonic-gate */ 3487c478bd9Sstevel@tonic-gate if ((cwdpath = getcwd(NULL, PATH_MAX)) == NULL) { 3497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 3507c478bd9Sstevel@tonic-gate gettext("%s : cannot get the current working " 3517c478bd9Sstevel@tonic-gate "directory\n"), cmdname); 3527c478bd9Sstevel@tonic-gate exit(1); 3537c478bd9Sstevel@tonic-gate } else 3547c478bd9Sstevel@tonic-gate free(cwdpath); 3557c478bd9Sstevel@tonic-gate 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate if (nftw(curpath, execute, 1000, walkflags)) { 3587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 3597c478bd9Sstevel@tonic-gate gettext("%s: cannot open %s: %s\n"), 3607c478bd9Sstevel@tonic-gate cmdname, curpath, strerror(errno)); 3617c478bd9Sstevel@tonic-gate error = 1; 3627c478bd9Sstevel@tonic-gate } 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate if (paths > 1) 3657c478bd9Sstevel@tonic-gate (void) memcpy(topnode, savetnode, 3667c478bd9Sstevel@tonic-gate ((argc + 1) * sizeof (struct Node))); 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate /* execute any remaining variable length lists */ 3707c478bd9Sstevel@tonic-gate while (lastlist) { 3717c478bd9Sstevel@tonic-gate if (lastlist->end != lastlist->nextstr) { 3727c478bd9Sstevel@tonic-gate *lastlist->nextvar = 0; 373*d35170d6Srm (void) doexec((char *)0, lastlist->arglist, 374*d35170d6Srm &exec_exitcode); 3757c478bd9Sstevel@tonic-gate } 3767c478bd9Sstevel@tonic-gate lastlist = lastlist->next; 3777c478bd9Sstevel@tonic-gate } 3787c478bd9Sstevel@tonic-gate if (output != stdout) 3797c478bd9Sstevel@tonic-gate return (cmdclose(output)); 380*d35170d6Srm return ((exec_exitcode != 0) ? exec_exitcode : error); 3817c478bd9Sstevel@tonic-gate } 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate /* 3847c478bd9Sstevel@tonic-gate * compile the arguments 3857c478bd9Sstevel@tonic-gate */ 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate static int 3887c478bd9Sstevel@tonic-gate compile(argv, np, actionp) 3897c478bd9Sstevel@tonic-gate char **argv; 3907c478bd9Sstevel@tonic-gate struct Node *np; 3917c478bd9Sstevel@tonic-gate int *actionp; 3927c478bd9Sstevel@tonic-gate { 3937c478bd9Sstevel@tonic-gate char *b; 3947c478bd9Sstevel@tonic-gate char **av; 3957c478bd9Sstevel@tonic-gate struct Node *oldnp = topnode; 3967c478bd9Sstevel@tonic-gate struct Args *argp; 3977c478bd9Sstevel@tonic-gate char **com; 3987c478bd9Sstevel@tonic-gate int i; 3997c478bd9Sstevel@tonic-gate enum Command wasop = PRINT; 4007c478bd9Sstevel@tonic-gate 4017c478bd9Sstevel@tonic-gate for (av = argv; *av && (argp = lookup(*av)); av++) { 4027c478bd9Sstevel@tonic-gate np->next = 0; 4037c478bd9Sstevel@tonic-gate np->action = argp->action; 4047c478bd9Sstevel@tonic-gate np->type = argp->type; 4057c478bd9Sstevel@tonic-gate np->second.i = 0; 4067c478bd9Sstevel@tonic-gate if (argp->type == Op) { 4077c478bd9Sstevel@tonic-gate if (wasop == NOT || (wasop && np->action != NOT)) { 4087c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4097c478bd9Sstevel@tonic-gate gettext("%s: operand follows operand\n"), 4107c478bd9Sstevel@tonic-gate cmdname); 4117c478bd9Sstevel@tonic-gate exit(1); 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate if (np->action != NOT && oldnp == 0) 4147c478bd9Sstevel@tonic-gate goto err; 4157c478bd9Sstevel@tonic-gate wasop = argp->action; 4167c478bd9Sstevel@tonic-gate } else { 4177c478bd9Sstevel@tonic-gate wasop = PRINT; 4187c478bd9Sstevel@tonic-gate if (argp->type != Unary) { 4197c478bd9Sstevel@tonic-gate if (!(b = *++av)) { 4207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4217c478bd9Sstevel@tonic-gate gettext("%s: incomplete statement\n"), 4227c478bd9Sstevel@tonic-gate cmdname); 4237c478bd9Sstevel@tonic-gate exit(1); 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate if (argp->type == Num) { 4267c478bd9Sstevel@tonic-gate if ((argp->action != PERM) || 4277c478bd9Sstevel@tonic-gate (*b != '+')) { 4287c478bd9Sstevel@tonic-gate if (*b == '+' || *b == '-') { 4297c478bd9Sstevel@tonic-gate np->second.i = *b; 4307c478bd9Sstevel@tonic-gate b++; 4317c478bd9Sstevel@tonic-gate } 4327c478bd9Sstevel@tonic-gate } 4337c478bd9Sstevel@tonic-gate } 4347c478bd9Sstevel@tonic-gate } 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate switch (argp->action) { 4377c478bd9Sstevel@tonic-gate case AND: 4387c478bd9Sstevel@tonic-gate break; 4397c478bd9Sstevel@tonic-gate case NOT: 4407c478bd9Sstevel@tonic-gate break; 4417c478bd9Sstevel@tonic-gate case OR: 4427c478bd9Sstevel@tonic-gate np->first.np = topnode; 4437c478bd9Sstevel@tonic-gate topnode = np; 4447c478bd9Sstevel@tonic-gate oldnp->next = 0; 4457c478bd9Sstevel@tonic-gate break; 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate case LPAREN: { 4487c478bd9Sstevel@tonic-gate struct Node *save = topnode; 4497c478bd9Sstevel@tonic-gate topnode = np+1; 4507c478bd9Sstevel@tonic-gate paren_cnt++; 4517c478bd9Sstevel@tonic-gate i = compile(++av, topnode, actionp); 4527c478bd9Sstevel@tonic-gate np->first.np = topnode; 4537c478bd9Sstevel@tonic-gate topnode = save; 4547c478bd9Sstevel@tonic-gate av += i; 4557c478bd9Sstevel@tonic-gate oldnp = np; 4567c478bd9Sstevel@tonic-gate np += i + 1; 4577c478bd9Sstevel@tonic-gate oldnp->next = np; 4587c478bd9Sstevel@tonic-gate continue; 4597c478bd9Sstevel@tonic-gate } 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate case RPAREN: 4627c478bd9Sstevel@tonic-gate if (paren_cnt <= 0) { 4637c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4647c478bd9Sstevel@tonic-gate gettext("%s: unmatched ')'\n"), 4657c478bd9Sstevel@tonic-gate cmdname); 4667c478bd9Sstevel@tonic-gate exit(1); 4677c478bd9Sstevel@tonic-gate } 4687c478bd9Sstevel@tonic-gate paren_cnt--; 4697c478bd9Sstevel@tonic-gate if (oldnp == 0) 4707c478bd9Sstevel@tonic-gate goto err; 4717c478bd9Sstevel@tonic-gate if (oldnp->type == Op) { 4727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4737c478bd9Sstevel@tonic-gate gettext("%s: cannot immediately" 4747c478bd9Sstevel@tonic-gate " follow an operand with ')'\n"), 4757c478bd9Sstevel@tonic-gate cmdname); 4767c478bd9Sstevel@tonic-gate exit(1); 4777c478bd9Sstevel@tonic-gate } 4787c478bd9Sstevel@tonic-gate oldnp->next = 0; 4797c478bd9Sstevel@tonic-gate return (av-argv); 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate case FOLLOW: 4827c478bd9Sstevel@tonic-gate walkflags &= ~FTW_PHYS; 4837c478bd9Sstevel@tonic-gate break; 4847c478bd9Sstevel@tonic-gate case MOUNT: 4857c478bd9Sstevel@tonic-gate walkflags |= FTW_MOUNT; 4867c478bd9Sstevel@tonic-gate break; 4877c478bd9Sstevel@tonic-gate case DEPTH: 4887c478bd9Sstevel@tonic-gate walkflags |= FTW_DEPTH; 4897c478bd9Sstevel@tonic-gate break; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate case LOCAL: 4927c478bd9Sstevel@tonic-gate np->first.l = 0L; 4937c478bd9Sstevel@tonic-gate np->first.ll = 0LL; 4947c478bd9Sstevel@tonic-gate np->second.i = '+'; 4957c478bd9Sstevel@tonic-gate /* 4967c478bd9Sstevel@tonic-gate * Make it compatible to df -l for 4977c478bd9Sstevel@tonic-gate * future enhancement. So, anything 4987c478bd9Sstevel@tonic-gate * that is not remote, then it is 4997c478bd9Sstevel@tonic-gate * local. 5007c478bd9Sstevel@tonic-gate */ 5017c478bd9Sstevel@tonic-gate init_remote_fs(); 5027c478bd9Sstevel@tonic-gate break; 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate case SIZE: 5057c478bd9Sstevel@tonic-gate if (b[strlen(b)-1] == 'c') 5067c478bd9Sstevel@tonic-gate np->action = CSIZE; 5077c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 5087c478bd9Sstevel@tonic-gate case INUM: 5097c478bd9Sstevel@tonic-gate np->first.ll = atoll(b); 5107c478bd9Sstevel@tonic-gate break; 5117c478bd9Sstevel@tonic-gate 512da1a9cbeSjonb case CMIN: 5137c478bd9Sstevel@tonic-gate case CTIME: 514da1a9cbeSjonb case MMIN: 5157c478bd9Sstevel@tonic-gate case MTIME: 516da1a9cbeSjonb case AMIN: 5177c478bd9Sstevel@tonic-gate case ATIME: 5187c478bd9Sstevel@tonic-gate case LINKS: 5197c478bd9Sstevel@tonic-gate np->first.l = atol(b); 5207c478bd9Sstevel@tonic-gate break; 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate case F_USER: 5237c478bd9Sstevel@tonic-gate case F_GROUP: { 5247c478bd9Sstevel@tonic-gate struct passwd *pw; 5257c478bd9Sstevel@tonic-gate struct group *gr; 5267c478bd9Sstevel@tonic-gate i = -1; 5277c478bd9Sstevel@tonic-gate if (argp->action == F_USER) { 5287c478bd9Sstevel@tonic-gate if ((pw = getpwnam(b)) != 0) 5297c478bd9Sstevel@tonic-gate i = (int)pw->pw_uid; 5307c478bd9Sstevel@tonic-gate } else { 5317c478bd9Sstevel@tonic-gate if ((gr = getgrnam(b)) != 0) 5327c478bd9Sstevel@tonic-gate i = (int)gr->gr_gid; 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate if (i == -1) { 5357c478bd9Sstevel@tonic-gate if (fnmatch("[0-9][0-9][0-9]*", b, 0) && 5367c478bd9Sstevel@tonic-gate fnmatch("[0-9][0-9]", b, 0) && 5377c478bd9Sstevel@tonic-gate fnmatch("[0-9]", b, 0)) { 5387c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 5397c478bd9Sstevel@tonic-gate "%s: cannot find %s name\n"), 5407c478bd9Sstevel@tonic-gate cmdname, *av); 5417c478bd9Sstevel@tonic-gate exit(1); 5427c478bd9Sstevel@tonic-gate } 5437c478bd9Sstevel@tonic-gate i = atoi(b); 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate np->first.l = i; 5467c478bd9Sstevel@tonic-gate break; 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate case EXEC: 5507c478bd9Sstevel@tonic-gate case OK: 5517c478bd9Sstevel@tonic-gate walkflags &= ~FTW_CHDIR; 5527c478bd9Sstevel@tonic-gate np->first.ap = av; 5537c478bd9Sstevel@tonic-gate (*actionp)++; 5547c478bd9Sstevel@tonic-gate for (;;) { 5557c478bd9Sstevel@tonic-gate if ((b = *av) == 0) { 5567c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5577c478bd9Sstevel@tonic-gate gettext("%s: incomplete statement\n"), 5587c478bd9Sstevel@tonic-gate cmdname); 5597c478bd9Sstevel@tonic-gate exit(1); 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate if (strcmp(b, ";") == 0) { 5627c478bd9Sstevel@tonic-gate *av = 0; 5637c478bd9Sstevel@tonic-gate break; 5647c478bd9Sstevel@tonic-gate } else if (strcmp(b, "{}") == 0) 5657c478bd9Sstevel@tonic-gate *av = dummyarg; 5667c478bd9Sstevel@tonic-gate else if (strcmp(b, "+") == 0 && 5677c478bd9Sstevel@tonic-gate av[-1] == dummyarg && 5687c478bd9Sstevel@tonic-gate np->action == EXEC) { 5697c478bd9Sstevel@tonic-gate av[-1] = 0; 5707c478bd9Sstevel@tonic-gate np->first.vp = varargs(np->first.ap); 5717c478bd9Sstevel@tonic-gate np->action = VARARGS; 5727c478bd9Sstevel@tonic-gate break; 5737c478bd9Sstevel@tonic-gate } 5747c478bd9Sstevel@tonic-gate av++; 5757c478bd9Sstevel@tonic-gate } 5767c478bd9Sstevel@tonic-gate break; 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate case NAME: 5797c478bd9Sstevel@tonic-gate np->first.cp = b; 5807c478bd9Sstevel@tonic-gate break; 5817c478bd9Sstevel@tonic-gate case PERM: 5827c478bd9Sstevel@tonic-gate if (*b == '-') 5837c478bd9Sstevel@tonic-gate ++b; 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate if (readmode(b) != NULL) { 5867c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 5877c478bd9Sstevel@tonic-gate "find: -perm: Bad permission string\n")); 5887c478bd9Sstevel@tonic-gate usage(); 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate np->first.l = (long)getmode((mode_t)0); 5917c478bd9Sstevel@tonic-gate break; 5927c478bd9Sstevel@tonic-gate case TYPE: 5937c478bd9Sstevel@tonic-gate i = *b; 5947c478bd9Sstevel@tonic-gate np->first.l = 5957c478bd9Sstevel@tonic-gate i == 'd' ? S_IFDIR : 5967c478bd9Sstevel@tonic-gate i == 'b' ? S_IFBLK : 5977c478bd9Sstevel@tonic-gate i == 'c' ? S_IFCHR : 5987c478bd9Sstevel@tonic-gate #ifdef S_IFIFO 5997c478bd9Sstevel@tonic-gate i == 'p' ? S_IFIFO : 6007c478bd9Sstevel@tonic-gate #endif 6017c478bd9Sstevel@tonic-gate i == 'f' ? S_IFREG : 6027c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 6037c478bd9Sstevel@tonic-gate i == 'l' ? S_IFLNK : 6047c478bd9Sstevel@tonic-gate #endif 6057c478bd9Sstevel@tonic-gate #ifdef S_IFSOCK 6067c478bd9Sstevel@tonic-gate i == 's' ? S_IFSOCK : 6077c478bd9Sstevel@tonic-gate #endif 6087c478bd9Sstevel@tonic-gate #ifdef S_IFDOOR 6097c478bd9Sstevel@tonic-gate i == 'D' ? S_IFDOOR : 6107c478bd9Sstevel@tonic-gate #endif 6117c478bd9Sstevel@tonic-gate 0; 6127c478bd9Sstevel@tonic-gate break; 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate case CPIO: 6157c478bd9Sstevel@tonic-gate if (walkflags & FTW_PHYS) 6167c478bd9Sstevel@tonic-gate com = cpio; 6177c478bd9Sstevel@tonic-gate else 6187c478bd9Sstevel@tonic-gate com = cpiol; 6197c478bd9Sstevel@tonic-gate goto common; 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate case NCPIO: { 6227c478bd9Sstevel@tonic-gate FILE *fd; 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate if (walkflags & FTW_PHYS) 6257c478bd9Sstevel@tonic-gate com = ncpio; 6267c478bd9Sstevel@tonic-gate else 6277c478bd9Sstevel@tonic-gate com = ncpiol; 6287c478bd9Sstevel@tonic-gate common: 6297c478bd9Sstevel@tonic-gate /* set up cpio */ 6307c478bd9Sstevel@tonic-gate if ((fd = fopen(b, "w")) == NULL) { 6317c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6327c478bd9Sstevel@tonic-gate gettext("%s: cannot create %s\n"), 6337c478bd9Sstevel@tonic-gate cmdname, b); 6347c478bd9Sstevel@tonic-gate exit(1); 6357c478bd9Sstevel@tonic-gate } 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate np->first.l = (long)cmdopen("cpio", com, "w", fd); 6387c478bd9Sstevel@tonic-gate (void) fclose(fd); 6397c478bd9Sstevel@tonic-gate walkflags |= FTW_DEPTH; 6407c478bd9Sstevel@tonic-gate np->action = CPIO; 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 6437c478bd9Sstevel@tonic-gate case PRINT: 6447c478bd9Sstevel@tonic-gate (*actionp)++; 6457c478bd9Sstevel@tonic-gate break; 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate case NEWER: { 6487c478bd9Sstevel@tonic-gate struct stat statb; 6497c478bd9Sstevel@tonic-gate if (stat(b, &statb) < 0) { 6507c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6517c478bd9Sstevel@tonic-gate gettext("%s: cannot access %s\n"), 6527c478bd9Sstevel@tonic-gate cmdname, b); 6537c478bd9Sstevel@tonic-gate exit(1); 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate np->first.l = statb.st_mtime; 6567c478bd9Sstevel@tonic-gate np->second.i = '+'; 6577c478bd9Sstevel@tonic-gate break; 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate case PRUNE: 6617c478bd9Sstevel@tonic-gate case NOUSER: 6627c478bd9Sstevel@tonic-gate case NOGRP: 6637c478bd9Sstevel@tonic-gate break; 6647c478bd9Sstevel@tonic-gate case FSTYPE: 6657c478bd9Sstevel@tonic-gate np->first.cp = b; 6667c478bd9Sstevel@tonic-gate break; 6677c478bd9Sstevel@tonic-gate case LS: 6687c478bd9Sstevel@tonic-gate (*actionp)++; 6697c478bd9Sstevel@tonic-gate break; 6707c478bd9Sstevel@tonic-gate case XATTR: 6717c478bd9Sstevel@tonic-gate break; 6727c478bd9Sstevel@tonic-gate case ACL: 6737c478bd9Sstevel@tonic-gate break; 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate oldnp = np++; 6777c478bd9Sstevel@tonic-gate oldnp->next = np; 6787c478bd9Sstevel@tonic-gate } 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate if ((*av) || (wasop)) 6817c478bd9Sstevel@tonic-gate goto err; 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate if (paren_cnt != 0) { 6847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: unmatched '('\n"), 6857c478bd9Sstevel@tonic-gate cmdname); 6867c478bd9Sstevel@tonic-gate exit(1); 6877c478bd9Sstevel@tonic-gate } 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate /* just before returning, save next free node from the list */ 6907c478bd9Sstevel@tonic-gate freenode = oldnp->next; 6917c478bd9Sstevel@tonic-gate oldnp->next = 0; 6927c478bd9Sstevel@tonic-gate return (av-argv); 6937c478bd9Sstevel@tonic-gate err: 6947c478bd9Sstevel@tonic-gate if (*av) 6957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6967c478bd9Sstevel@tonic-gate gettext("%s: bad option %s\n"), cmdname, *av); 6977c478bd9Sstevel@tonic-gate else 6987c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: bad option\n"), cmdname); 6997c478bd9Sstevel@tonic-gate usage(); 7007c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 7017c478bd9Sstevel@tonic-gate } 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate /* 7047c478bd9Sstevel@tonic-gate * print out a usage message 7057c478bd9Sstevel@tonic-gate */ 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate static void 7086c83d09fSrobbin usage(void) 7097c478bd9Sstevel@tonic-gate { 7107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7117c478bd9Sstevel@tonic-gate gettext("%s: [-H | -L] path-list predicate-list\n"), cmdname); 7127c478bd9Sstevel@tonic-gate exit(1); 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate /* 7167c478bd9Sstevel@tonic-gate * This is the function that gets executed at each node 7177c478bd9Sstevel@tonic-gate */ 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate static int 7207c478bd9Sstevel@tonic-gate execute(name, statb, type, state) 7217c478bd9Sstevel@tonic-gate char *name; 7227c478bd9Sstevel@tonic-gate struct stat *statb; 7237c478bd9Sstevel@tonic-gate int type; 7247c478bd9Sstevel@tonic-gate struct FTW *state; 7257c478bd9Sstevel@tonic-gate { 7267c478bd9Sstevel@tonic-gate struct Node *np = topnode; 7277c478bd9Sstevel@tonic-gate int val; 7287c478bd9Sstevel@tonic-gate time_t t; 7297c478bd9Sstevel@tonic-gate long l; 7307c478bd9Sstevel@tonic-gate long long ll; 7317c478bd9Sstevel@tonic-gate int not = 1; 7327c478bd9Sstevel@tonic-gate char *filename; 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate if (type == FTW_NS) { 7357c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: stat() error %s: %s\n"), 7367c478bd9Sstevel@tonic-gate cmdname, name, strerror(errno)); 7377c478bd9Sstevel@tonic-gate error = 1; 7387c478bd9Sstevel@tonic-gate return (0); 7397c478bd9Sstevel@tonic-gate } else if (type == FTW_DNR) { 7407c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: cannot read dir %s: %s\n"), 7417c478bd9Sstevel@tonic-gate cmdname, name, strerror(errno)); 7427c478bd9Sstevel@tonic-gate error = 1; 7437c478bd9Sstevel@tonic-gate return (0); 7447c478bd9Sstevel@tonic-gate } else if (type == FTW_SLN && lflag == 0) { 7457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7467c478bd9Sstevel@tonic-gate gettext("%s: cannot follow symbolic link %s: %s\n"), 7477c478bd9Sstevel@tonic-gate cmdname, name, strerror(errno)); 7487c478bd9Sstevel@tonic-gate error = 1; 7497c478bd9Sstevel@tonic-gate return (0); 7507c478bd9Sstevel@tonic-gate } 7517c478bd9Sstevel@tonic-gate 7527c478bd9Sstevel@tonic-gate while (np) { 7537c478bd9Sstevel@tonic-gate switch (np->action) { 7547c478bd9Sstevel@tonic-gate case NOT: 7557c478bd9Sstevel@tonic-gate not = !not; 7567c478bd9Sstevel@tonic-gate np = np->next; 7577c478bd9Sstevel@tonic-gate continue; 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate case AND: 7607c478bd9Sstevel@tonic-gate np = np->next; 7617c478bd9Sstevel@tonic-gate continue; 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate case OR: 7647c478bd9Sstevel@tonic-gate if (np->first.np == np) { 7657c478bd9Sstevel@tonic-gate /* 7667c478bd9Sstevel@tonic-gate * handle naked OR (no term on left hand side) 7677c478bd9Sstevel@tonic-gate */ 7687c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7697c478bd9Sstevel@tonic-gate gettext("%s: invalid -o construction\n"), 7707c478bd9Sstevel@tonic-gate cmdname); 7717c478bd9Sstevel@tonic-gate exit(2); 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 7747c478bd9Sstevel@tonic-gate case LPAREN: { 7757c478bd9Sstevel@tonic-gate struct Node *save = topnode; 7767c478bd9Sstevel@tonic-gate topnode = np->first.np; 7777c478bd9Sstevel@tonic-gate (void) execute(name, statb, type, state); 7787c478bd9Sstevel@tonic-gate val = lastval; 7797c478bd9Sstevel@tonic-gate topnode = save; 7807c478bd9Sstevel@tonic-gate if (np->action == OR) { 7817c478bd9Sstevel@tonic-gate if (val) 7827c478bd9Sstevel@tonic-gate return (0); 7837c478bd9Sstevel@tonic-gate val = 1; 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate break; 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate case LOCAL: { 7897c478bd9Sstevel@tonic-gate int nremfs; 7907c478bd9Sstevel@tonic-gate val = 1; 7917c478bd9Sstevel@tonic-gate /* 7927c478bd9Sstevel@tonic-gate * If file system type matches the remote 7937c478bd9Sstevel@tonic-gate * file system type, then it is not local. 7947c478bd9Sstevel@tonic-gate */ 7957c478bd9Sstevel@tonic-gate for (nremfs = 0; nremfs < fstype_index; nremfs++) { 7967c478bd9Sstevel@tonic-gate if (strcmp(remote_fstypes[nremfs], 7977c478bd9Sstevel@tonic-gate statb->st_fstype) == 0) { 7987c478bd9Sstevel@tonic-gate val = 0; 7997c478bd9Sstevel@tonic-gate break; 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate } 8027c478bd9Sstevel@tonic-gate break; 8037c478bd9Sstevel@tonic-gate } 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate case TYPE: 8067c478bd9Sstevel@tonic-gate l = (long)statb->st_mode&S_IFMT; 8077c478bd9Sstevel@tonic-gate goto num; 8087c478bd9Sstevel@tonic-gate 8097c478bd9Sstevel@tonic-gate case PERM: 8107c478bd9Sstevel@tonic-gate l = (long)statb->st_mode&07777; 8117c478bd9Sstevel@tonic-gate if (np->second.i == '-') 8127c478bd9Sstevel@tonic-gate val = ((l&np->first.l) == np->first.l); 8137c478bd9Sstevel@tonic-gate else 8147c478bd9Sstevel@tonic-gate val = (l == np->first.l); 8157c478bd9Sstevel@tonic-gate break; 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate case INUM: 8187c478bd9Sstevel@tonic-gate ll = (long long)statb->st_ino; 8197c478bd9Sstevel@tonic-gate goto llnum; 8207c478bd9Sstevel@tonic-gate case NEWER: 8217c478bd9Sstevel@tonic-gate l = statb->st_mtime; 8227c478bd9Sstevel@tonic-gate goto num; 8237c478bd9Sstevel@tonic-gate case ATIME: 8247c478bd9Sstevel@tonic-gate t = statb->st_atime; 8257c478bd9Sstevel@tonic-gate goto days; 8267c478bd9Sstevel@tonic-gate case CTIME: 8277c478bd9Sstevel@tonic-gate t = statb->st_ctime; 8287c478bd9Sstevel@tonic-gate goto days; 8297c478bd9Sstevel@tonic-gate case MTIME: 8307c478bd9Sstevel@tonic-gate t = statb->st_mtime; 8317c478bd9Sstevel@tonic-gate days: 8327c478bd9Sstevel@tonic-gate l = (now-t)/A_DAY; 8337c478bd9Sstevel@tonic-gate goto num; 834da1a9cbeSjonb case MMIN: 835da1a9cbeSjonb t = statb->st_mtime; 836da1a9cbeSjonb goto mins; 837da1a9cbeSjonb case AMIN: 838da1a9cbeSjonb t = statb->st_atime; 839da1a9cbeSjonb goto mins; 840da1a9cbeSjonb case CMIN: 841da1a9cbeSjonb t = statb->st_ctime; 842da1a9cbeSjonb goto mins; 843da1a9cbeSjonb mins: 844da1a9cbeSjonb l = (now-t)/A_MIN; 845da1a9cbeSjonb goto num; 8467c478bd9Sstevel@tonic-gate case CSIZE: 8477c478bd9Sstevel@tonic-gate ll = (long long)statb->st_size; 8487c478bd9Sstevel@tonic-gate goto llnum; 8497c478bd9Sstevel@tonic-gate case SIZE: 8507c478bd9Sstevel@tonic-gate ll = (long long)round(statb->st_size, BLKSIZ)/BLKSIZ; 8517c478bd9Sstevel@tonic-gate goto llnum; 8527c478bd9Sstevel@tonic-gate case F_USER: 8537c478bd9Sstevel@tonic-gate l = (long)statb->st_uid; 8547c478bd9Sstevel@tonic-gate goto num; 8557c478bd9Sstevel@tonic-gate case F_GROUP: 8567c478bd9Sstevel@tonic-gate l = (long)statb->st_gid; 8577c478bd9Sstevel@tonic-gate goto num; 8587c478bd9Sstevel@tonic-gate case LINKS: 8597c478bd9Sstevel@tonic-gate l = (long)statb->st_nlink; 8607c478bd9Sstevel@tonic-gate goto num; 8617c478bd9Sstevel@tonic-gate llnum: 8627c478bd9Sstevel@tonic-gate if (np->second.i == '+') 8637c478bd9Sstevel@tonic-gate val = (ll > np->first.ll); 8647c478bd9Sstevel@tonic-gate else if (np->second.i == '-') 8657c478bd9Sstevel@tonic-gate val = (ll < np->first.ll); 8667c478bd9Sstevel@tonic-gate else 8677c478bd9Sstevel@tonic-gate val = (ll == np->first.ll); 8687c478bd9Sstevel@tonic-gate break; 8697c478bd9Sstevel@tonic-gate num: 8707c478bd9Sstevel@tonic-gate if (np->second.i == '+') 8717c478bd9Sstevel@tonic-gate val = (l > np->first.l); 8727c478bd9Sstevel@tonic-gate else if (np->second.i == '-') 8737c478bd9Sstevel@tonic-gate val = (l < np->first.l); 8747c478bd9Sstevel@tonic-gate else 8757c478bd9Sstevel@tonic-gate val = (l == np->first.l); 8767c478bd9Sstevel@tonic-gate break; 8777c478bd9Sstevel@tonic-gate case OK: 8787c478bd9Sstevel@tonic-gate val = ok(name, np->first.ap); 8797c478bd9Sstevel@tonic-gate break; 8807c478bd9Sstevel@tonic-gate case EXEC: 881*d35170d6Srm val = doexec(name, np->first.ap, NULL); 8827c478bd9Sstevel@tonic-gate break; 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate case VARARGS: { 8857c478bd9Sstevel@tonic-gate struct Arglist *ap = np->first.vp; 8867c478bd9Sstevel@tonic-gate char *cp; 8877c478bd9Sstevel@tonic-gate cp = ap->nextstr - (strlen(name)+1); 8887c478bd9Sstevel@tonic-gate if (cp >= (char *)(ap->nextvar+3)) { 8897c478bd9Sstevel@tonic-gate /* there is room just copy the name */ 8907c478bd9Sstevel@tonic-gate val = 1; 8917c478bd9Sstevel@tonic-gate (void) strcpy(cp, name); 8927c478bd9Sstevel@tonic-gate *ap->nextvar++ = cp; 8937c478bd9Sstevel@tonic-gate ap->nextstr = cp; 8947c478bd9Sstevel@tonic-gate } else { 8957c478bd9Sstevel@tonic-gate /* no more room, exec command */ 8967c478bd9Sstevel@tonic-gate *ap->nextvar++ = name; 8977c478bd9Sstevel@tonic-gate *ap->nextvar = 0; 8987c478bd9Sstevel@tonic-gate val = 1; 899*d35170d6Srm (void) doexec((char *)0, ap->arglist, 900*d35170d6Srm &exec_exitcode); 9017c478bd9Sstevel@tonic-gate ap->nextstr = ap->end; 9027c478bd9Sstevel@tonic-gate ap->nextvar = ap->firstvar; 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate break; 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate case DEPTH: 9087c478bd9Sstevel@tonic-gate case MOUNT: 9097c478bd9Sstevel@tonic-gate case FOLLOW: 9107c478bd9Sstevel@tonic-gate val = 1; 9117c478bd9Sstevel@tonic-gate break; 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate case NAME: { 9147c478bd9Sstevel@tonic-gate /* 9157c478bd9Sstevel@tonic-gate * XPG4 find should not treat a leading '.' in a 9167c478bd9Sstevel@tonic-gate * filename specially for pattern matching. 9177c478bd9Sstevel@tonic-gate * /usr/bin/find will not pattern match a leading 9187c478bd9Sstevel@tonic-gate * '.' in a filename, unless '.' is explicitly 9197c478bd9Sstevel@tonic-gate * specified. 9207c478bd9Sstevel@tonic-gate */ 9217c478bd9Sstevel@tonic-gate #ifdef XPG4 9227c478bd9Sstevel@tonic-gate val = !fnmatch(np->first.cp, 9237c478bd9Sstevel@tonic-gate name+state->base, 0); 9247c478bd9Sstevel@tonic-gate #else 9257c478bd9Sstevel@tonic-gate val = !fnmatch(np->first.cp, 9267c478bd9Sstevel@tonic-gate name+state->base, FNM_PERIOD); 9277c478bd9Sstevel@tonic-gate #endif 9287c478bd9Sstevel@tonic-gate break; 9297c478bd9Sstevel@tonic-gate } 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate case PRUNE: 9327c478bd9Sstevel@tonic-gate if (type == FTW_D) 9337c478bd9Sstevel@tonic-gate state->quit = FTW_PRUNE; 9347c478bd9Sstevel@tonic-gate val = 1; 9357c478bd9Sstevel@tonic-gate break; 9367c478bd9Sstevel@tonic-gate case NOUSER: 9377c478bd9Sstevel@tonic-gate val = ((getpwuid(statb->st_uid)) == 0); 9387c478bd9Sstevel@tonic-gate break; 9397c478bd9Sstevel@tonic-gate case NOGRP: 9407c478bd9Sstevel@tonic-gate val = ((getgrgid(statb->st_gid)) == 0); 9417c478bd9Sstevel@tonic-gate break; 9427c478bd9Sstevel@tonic-gate case FSTYPE: 9437c478bd9Sstevel@tonic-gate val = (strcmp(np->first.cp, statb->st_fstype) == 0); 9447c478bd9Sstevel@tonic-gate break; 9457c478bd9Sstevel@tonic-gate case CPIO: 9467c478bd9Sstevel@tonic-gate output = (FILE *)np->first.l; 9477c478bd9Sstevel@tonic-gate (void) fprintf(output, "%s\n", name); 9487c478bd9Sstevel@tonic-gate val = 1; 9497c478bd9Sstevel@tonic-gate break; 9507c478bd9Sstevel@tonic-gate case PRINT: 9517c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "%s\n", name); 9527c478bd9Sstevel@tonic-gate val = 1; 9537c478bd9Sstevel@tonic-gate break; 9547c478bd9Sstevel@tonic-gate case LS: 9557c478bd9Sstevel@tonic-gate (void) list(name, statb); 9567c478bd9Sstevel@tonic-gate val = 1; 9577c478bd9Sstevel@tonic-gate break; 9587c478bd9Sstevel@tonic-gate case XATTR: 9597c478bd9Sstevel@tonic-gate filename = gettail(name); 9607c478bd9Sstevel@tonic-gate val = (pathconf(filename, _PC_XATTR_EXISTS) == 1); 9617c478bd9Sstevel@tonic-gate break; 9627c478bd9Sstevel@tonic-gate case ACL: 9637c478bd9Sstevel@tonic-gate /* 9647c478bd9Sstevel@tonic-gate * Need to get the tail of the file name, since we have 9657c478bd9Sstevel@tonic-gate * already chdir()ed into the directory (performed in 9667c478bd9Sstevel@tonic-gate * nftw()) of the file 9677c478bd9Sstevel@tonic-gate */ 9687c478bd9Sstevel@tonic-gate filename = gettail(name); 969fa9e4066Sahrens val = acl_trivial(name); 9707c478bd9Sstevel@tonic-gate break; 9717c478bd9Sstevel@tonic-gate } 9727c478bd9Sstevel@tonic-gate /* 9737c478bd9Sstevel@tonic-gate * evaluate 'val' and 'not' (exclusive-or) 9747c478bd9Sstevel@tonic-gate * if no inversion (not == 1), return only when val == 0 9757c478bd9Sstevel@tonic-gate * (primary not true). Otherwise, invert the primary 9767c478bd9Sstevel@tonic-gate * and return when the primary is true. 9777c478bd9Sstevel@tonic-gate * 'Lastval' saves the last result (fail or pass) when 9787c478bd9Sstevel@tonic-gate * returning back to the calling routine. 9797c478bd9Sstevel@tonic-gate */ 9807c478bd9Sstevel@tonic-gate if (val^not) { 9817c478bd9Sstevel@tonic-gate lastval = 0; 9827c478bd9Sstevel@tonic-gate return (0); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate lastval = 1; 9857c478bd9Sstevel@tonic-gate not = 1; 9867c478bd9Sstevel@tonic-gate np = np->next; 9877c478bd9Sstevel@tonic-gate } 9887c478bd9Sstevel@tonic-gate return (0); 9897c478bd9Sstevel@tonic-gate } 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate /* 9927c478bd9Sstevel@tonic-gate * code for the -ok option 9937c478bd9Sstevel@tonic-gate */ 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate static int 9967c478bd9Sstevel@tonic-gate ok(name, argv) 9977c478bd9Sstevel@tonic-gate char *name; 9987c478bd9Sstevel@tonic-gate char *argv[]; 9997c478bd9Sstevel@tonic-gate { 10007c478bd9Sstevel@tonic-gate int c, yes = 0; 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate (void) fflush(stdout); /* to flush possible `-print' */ 10037c478bd9Sstevel@tonic-gate 10047c478bd9Sstevel@tonic-gate if ((*argv != dummyarg) && (strcmp(*argv, name))) 10057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "< %s ... %s >? ", *argv, name); 10067c478bd9Sstevel@tonic-gate else 10077c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "< {} ... %s >? ", name); 10087c478bd9Sstevel@tonic-gate 10097c478bd9Sstevel@tonic-gate (void) fflush(stderr); 10107c478bd9Sstevel@tonic-gate if ((c = tolower(getchar())) == *nl_langinfo(YESSTR)) 10117c478bd9Sstevel@tonic-gate yes = 1; 10127c478bd9Sstevel@tonic-gate while (c != '\n') 10137c478bd9Sstevel@tonic-gate if (c == EOF) 10147c478bd9Sstevel@tonic-gate exit(2); 10157c478bd9Sstevel@tonic-gate else 10167c478bd9Sstevel@tonic-gate c = getchar(); 1017*d35170d6Srm return (yes? doexec(name, argv, NULL): 0); 10187c478bd9Sstevel@tonic-gate } 10197c478bd9Sstevel@tonic-gate 10207c478bd9Sstevel@tonic-gate /* 10217c478bd9Sstevel@tonic-gate * execute argv with {} replaced by name 1022*d35170d6Srm * 1023*d35170d6Srm * Per XPG6, find must exit non-zero if an invocation through 1024*d35170d6Srm * -exec, punctuated by a plus sign, exits non-zero, so set 1025*d35170d6Srm * exitcode if we see a non-zero exit. 1026*d35170d6Srm * exitcode should be NULL when -exec or -ok is not punctuated 1027*d35170d6Srm * by a plus sign. 10287c478bd9Sstevel@tonic-gate */ 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate static int 1031*d35170d6Srm doexec(char *name, char *argv[], int *exitcode) 10327c478bd9Sstevel@tonic-gate { 10337c478bd9Sstevel@tonic-gate char *cp; 10347c478bd9Sstevel@tonic-gate char **av = argv; 1035*d35170d6Srm char *newargs[1 + SHELL_MAXARGS + 1]; 10367c478bd9Sstevel@tonic-gate int dummyseen = 0; 1037*d35170d6Srm int i, j, status, rc, r = 0; 1038*d35170d6Srm int exit_status = 0; 1039*d35170d6Srm pid_t pid, pid1; 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate (void) fflush(stdout); /* to flush possible `-print' */ 10427c478bd9Sstevel@tonic-gate if (name) { 10437c478bd9Sstevel@tonic-gate while (cp = *av++) { 10447c478bd9Sstevel@tonic-gate if (cp == dummyarg) { 10457c478bd9Sstevel@tonic-gate dummyseen = 1; 10467c478bd9Sstevel@tonic-gate av[-1] = name; 10477c478bd9Sstevel@tonic-gate } 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate } 10507c478bd9Sstevel@tonic-gate } 10517c478bd9Sstevel@tonic-gate if (argv[0] == NULL) /* null command line */ 10527c478bd9Sstevel@tonic-gate return (r); 10537c478bd9Sstevel@tonic-gate 1054*d35170d6Srm if ((pid = fork()) == -1) { 1055*d35170d6Srm /* fork failed */ 1056*d35170d6Srm if (exitcode != NULL) 1057*d35170d6Srm *exitcode = 1; 1058*d35170d6Srm return (0); 1059*d35170d6Srm } 1060*d35170d6Srm if (pid != 0) { 1061*d35170d6Srm /* parent */ 1062*d35170d6Srm do { 1063*d35170d6Srm /* wait for child to exit */ 1064*d35170d6Srm if ((rc = wait(&r)) == -1 && errno != EINTR) { 1065*d35170d6Srm (void) fprintf(stderr, 1066*d35170d6Srm gettext("wait failed %s"), strerror(errno)); 1067*d35170d6Srm 1068*d35170d6Srm if (exitcode != NULL) 1069*d35170d6Srm *exitcode = 1; 1070*d35170d6Srm return (0); 1071*d35170d6Srm } 1072*d35170d6Srm } while (rc != pid); 1073*d35170d6Srm } else { 1074*d35170d6Srm /* child */ 10757c478bd9Sstevel@tonic-gate (void) execvp(argv[0], argv); 1076*d35170d6Srm if (errno != E2BIG) 1077*d35170d6Srm exit(1); 1078*d35170d6Srm 1079*d35170d6Srm /* 1080*d35170d6Srm * We are in a situation where argv[0] points to a 1081*d35170d6Srm * script without the interpreter line, e.g. #!/bin/sh. 1082*d35170d6Srm * execvp() will execute either /usr/bin/sh or 1083*d35170d6Srm * /usr/xpg4/bin/sh against the script, and you will be 1084*d35170d6Srm * limited to SHELL_MAXARGS arguments. If you try to 1085*d35170d6Srm * pass more than SHELL_MAXARGS arguments, execvp() 1086*d35170d6Srm * fails with E2BIG. 1087*d35170d6Srm * See usr/src/lib/libc/port/gen/execvp.c. 1088*d35170d6Srm * 1089*d35170d6Srm * In this situation, process the argument list by 1090*d35170d6Srm * packets of SHELL_MAXARGS arguments with respect of 1091*d35170d6Srm * the following rules: 1092*d35170d6Srm * 1. the invocations have to complete before find exits 1093*d35170d6Srm * 2. only one invocation can be running at a time 1094*d35170d6Srm */ 1095*d35170d6Srm 1096*d35170d6Srm i = 1; 1097*d35170d6Srm newargs[0] = argv[0]; 1098*d35170d6Srm 1099*d35170d6Srm while (argv[i]) { 1100*d35170d6Srm j = 1; 1101*d35170d6Srm while (j <= SHELL_MAXARGS && argv[i]) { 1102*d35170d6Srm newargs[j++] = argv[i++]; 1103*d35170d6Srm } 1104*d35170d6Srm newargs[j] = NULL; 1105*d35170d6Srm 1106*d35170d6Srm if ((pid1 = fork()) == -1) { 1107*d35170d6Srm /* fork failed */ 1108*d35170d6Srm exit(1); 1109*d35170d6Srm } 1110*d35170d6Srm if (pid1 == 0) { 1111*d35170d6Srm /* child */ 1112*d35170d6Srm (void) execvp(newargs[0], newargs); 1113*d35170d6Srm exit(1); 1114*d35170d6Srm } 1115*d35170d6Srm 1116*d35170d6Srm status = 0; 1117*d35170d6Srm 1118*d35170d6Srm do { 1119*d35170d6Srm /* wait for the child to exit */ 1120*d35170d6Srm if ((rc = wait(&status)) == -1 && 1121*d35170d6Srm errno != EINTR) { 1122*d35170d6Srm (void) fprintf(stderr, 1123*d35170d6Srm gettext("wait failed %s"), 1124*d35170d6Srm strerror(errno)); 1125*d35170d6Srm exit(1); 1126*d35170d6Srm } 1127*d35170d6Srm } while (rc != pid1); 1128*d35170d6Srm 1129*d35170d6Srm if (status) 1130*d35170d6Srm exit_status = 1; 1131*d35170d6Srm } 1132*d35170d6Srm /* all the invocations have completed */ 1133*d35170d6Srm exit(exit_status); 11347c478bd9Sstevel@tonic-gate } 1135*d35170d6Srm 11367c478bd9Sstevel@tonic-gate if (name && dummyseen) { 11377c478bd9Sstevel@tonic-gate for (av = argv; cp = *av++; ) { 11387c478bd9Sstevel@tonic-gate if (cp == name) 11397c478bd9Sstevel@tonic-gate av[-1] = dummyarg; 11407c478bd9Sstevel@tonic-gate } 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate 1143*d35170d6Srm if (r && exitcode != NULL) 1144*d35170d6Srm *exitcode = 3; /* use to indicate error in cmd invocation */ 1145*d35170d6Srm 11467c478bd9Sstevel@tonic-gate return (!r); 11477c478bd9Sstevel@tonic-gate } 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate /* 11517c478bd9Sstevel@tonic-gate * Table lookup routine 11527c478bd9Sstevel@tonic-gate */ 11537c478bd9Sstevel@tonic-gate static struct Args * 11547c478bd9Sstevel@tonic-gate lookup(word) 11557c478bd9Sstevel@tonic-gate char *word; 11567c478bd9Sstevel@tonic-gate { 11577c478bd9Sstevel@tonic-gate struct Args *argp = commands; 11587c478bd9Sstevel@tonic-gate int second; 11597c478bd9Sstevel@tonic-gate if (word == 0 || *word == 0) 11607c478bd9Sstevel@tonic-gate return (0); 11617c478bd9Sstevel@tonic-gate second = word[1]; 11627c478bd9Sstevel@tonic-gate while (*argp->name) { 11637c478bd9Sstevel@tonic-gate if (second == argp->name[1] && strcmp(word, argp->name) == 0) 11647c478bd9Sstevel@tonic-gate return (argp); 11657c478bd9Sstevel@tonic-gate argp++; 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate return (0); 11687c478bd9Sstevel@tonic-gate } 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate /* 11727c478bd9Sstevel@tonic-gate * Get space for variable length argument list 11737c478bd9Sstevel@tonic-gate */ 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate static struct Arglist * 11767c478bd9Sstevel@tonic-gate varargs(com) 11777c478bd9Sstevel@tonic-gate char **com; 11787c478bd9Sstevel@tonic-gate { 11797c478bd9Sstevel@tonic-gate struct Arglist *ap; 11807c478bd9Sstevel@tonic-gate int n; 11817c478bd9Sstevel@tonic-gate char **ep; 11827c478bd9Sstevel@tonic-gate if (varsize == 0) { 11837c478bd9Sstevel@tonic-gate n = 2*sizeof (char **); 11847c478bd9Sstevel@tonic-gate for (ep = environ; *ep; ep++) 11857c478bd9Sstevel@tonic-gate n += (strlen(*ep)+sizeof (ep) + 1); 11867c478bd9Sstevel@tonic-gate varsize = sizeof (struct Arglist)+ARG_MAX-PATH_MAX-n-1; 11877c478bd9Sstevel@tonic-gate } 11887c478bd9Sstevel@tonic-gate ap = (struct Arglist *)malloc(varsize+1); 11897c478bd9Sstevel@tonic-gate ap->end = (char *)ap + varsize; 11907c478bd9Sstevel@tonic-gate ap->nextstr = ap->end; 11917c478bd9Sstevel@tonic-gate ap->nextvar = ap->arglist; 11927c478bd9Sstevel@tonic-gate while (*ap->nextvar++ = *com++); 11937c478bd9Sstevel@tonic-gate ap->nextvar--; 11947c478bd9Sstevel@tonic-gate ap->firstvar = ap->nextvar; 11957c478bd9Sstevel@tonic-gate ap->next = lastlist; 11967c478bd9Sstevel@tonic-gate lastlist = ap; 11977c478bd9Sstevel@tonic-gate return (ap); 11987c478bd9Sstevel@tonic-gate } 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate /* 12017c478bd9Sstevel@tonic-gate * filter command support 12027c478bd9Sstevel@tonic-gate * fork and exec cmd(argv) according to mode: 12037c478bd9Sstevel@tonic-gate * 12047c478bd9Sstevel@tonic-gate * "r" with fp as stdin of cmd (default stdin), cmd stdout returned 12057c478bd9Sstevel@tonic-gate * "w" with fp as stdout of cmd (default stdout), cmd stdin returned 12067c478bd9Sstevel@tonic-gate */ 12077c478bd9Sstevel@tonic-gate 12087c478bd9Sstevel@tonic-gate #define CMDERR ((1<<8)-1) /* command error exit code */ 12097c478bd9Sstevel@tonic-gate #define MAXCMDS 8 /* max # simultaneous cmdopen()'s */ 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate static struct /* info for each cmdopen() */ 12127c478bd9Sstevel@tonic-gate { 12137c478bd9Sstevel@tonic-gate FILE *fp; /* returned by cmdopen() */ 12147c478bd9Sstevel@tonic-gate pid_t pid; /* pid used by cmdopen() */ 12157c478bd9Sstevel@tonic-gate } cmdproc[MAXCMDS]; 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate static FILE * 12187c478bd9Sstevel@tonic-gate cmdopen(cmd, argv, mode, fp) 12197c478bd9Sstevel@tonic-gate char *cmd; 12207c478bd9Sstevel@tonic-gate char **argv; 12217c478bd9Sstevel@tonic-gate char *mode; 12227c478bd9Sstevel@tonic-gate FILE *fp; 12237c478bd9Sstevel@tonic-gate { 12247c478bd9Sstevel@tonic-gate int proc; 12257c478bd9Sstevel@tonic-gate int cmdfd; 12267c478bd9Sstevel@tonic-gate int usrfd; 12277c478bd9Sstevel@tonic-gate int pio[2]; 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate switch (*mode) { 12307c478bd9Sstevel@tonic-gate case 'r': 12317c478bd9Sstevel@tonic-gate cmdfd = 1; 12327c478bd9Sstevel@tonic-gate usrfd = 0; 12337c478bd9Sstevel@tonic-gate break; 12347c478bd9Sstevel@tonic-gate case 'w': 12357c478bd9Sstevel@tonic-gate cmdfd = 0; 12367c478bd9Sstevel@tonic-gate usrfd = 1; 12377c478bd9Sstevel@tonic-gate break; 12387c478bd9Sstevel@tonic-gate default: 12397c478bd9Sstevel@tonic-gate return (0); 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate for (proc = 0; proc < MAXCMDS; proc++) 12437c478bd9Sstevel@tonic-gate if (!cmdproc[proc].fp) 12447c478bd9Sstevel@tonic-gate break; 12457c478bd9Sstevel@tonic-gate if (proc >= MAXCMDS) 12467c478bd9Sstevel@tonic-gate return (0); 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate if (pipe(pio)) 12497c478bd9Sstevel@tonic-gate return (0); 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate switch (cmdproc[proc].pid = fork()) { 12527c478bd9Sstevel@tonic-gate case -1: 12537c478bd9Sstevel@tonic-gate return (0); 12547c478bd9Sstevel@tonic-gate case 0: 12557c478bd9Sstevel@tonic-gate if (fp && fileno(fp) != usrfd) { 12567c478bd9Sstevel@tonic-gate (void) close(usrfd); 12577c478bd9Sstevel@tonic-gate if (dup2(fileno(fp), usrfd) != usrfd) 12587c478bd9Sstevel@tonic-gate _exit(CMDERR); 12597c478bd9Sstevel@tonic-gate (void) close(fileno(fp)); 12607c478bd9Sstevel@tonic-gate } 12617c478bd9Sstevel@tonic-gate (void) close(cmdfd); 12627c478bd9Sstevel@tonic-gate if (dup2(pio[cmdfd], cmdfd) != cmdfd) 12637c478bd9Sstevel@tonic-gate _exit(CMDERR); 12647c478bd9Sstevel@tonic-gate (void) close(pio[cmdfd]); 12657c478bd9Sstevel@tonic-gate (void) close(pio[usrfd]); 12667c478bd9Sstevel@tonic-gate (void) execvp(cmd, argv); 12677c478bd9Sstevel@tonic-gate if (errno == ENOEXEC) { 12687c478bd9Sstevel@tonic-gate char **p; 12697c478bd9Sstevel@tonic-gate char **v; 12707c478bd9Sstevel@tonic-gate 12717c478bd9Sstevel@tonic-gate /* 12727c478bd9Sstevel@tonic-gate * assume cmd is a shell script 12737c478bd9Sstevel@tonic-gate */ 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate p = argv; 12767c478bd9Sstevel@tonic-gate while (*p++); 12777c478bd9Sstevel@tonic-gate if (v = (char **)malloc((p - argv + 1) * 12787c478bd9Sstevel@tonic-gate sizeof (char **))) { 12797c478bd9Sstevel@tonic-gate p = v; 12807c478bd9Sstevel@tonic-gate *p++ = cmd; 12817c478bd9Sstevel@tonic-gate if (*argv) argv++; 12827c478bd9Sstevel@tonic-gate while (*p++ = *argv++); 12837c478bd9Sstevel@tonic-gate (void) execv(getshell(), v); 12847c478bd9Sstevel@tonic-gate } 12857c478bd9Sstevel@tonic-gate } 12867c478bd9Sstevel@tonic-gate _exit(CMDERR); 12877c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 12887c478bd9Sstevel@tonic-gate default: 12897c478bd9Sstevel@tonic-gate (void) close(pio[cmdfd]); 12907c478bd9Sstevel@tonic-gate return (cmdproc[proc].fp = fdopen(pio[usrfd], mode)); 12917c478bd9Sstevel@tonic-gate } 12927c478bd9Sstevel@tonic-gate } 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate /* 12957c478bd9Sstevel@tonic-gate * close a stream opened by cmdopen() 12967c478bd9Sstevel@tonic-gate * -1 returned if cmdopen() had a problem 12977c478bd9Sstevel@tonic-gate * otherwise exit() status of command is returned 12987c478bd9Sstevel@tonic-gate */ 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate static int 13017c478bd9Sstevel@tonic-gate cmdclose(fp) 13027c478bd9Sstevel@tonic-gate FILE *fp; 13037c478bd9Sstevel@tonic-gate { 13047c478bd9Sstevel@tonic-gate int i; 13057c478bd9Sstevel@tonic-gate pid_t p, pid; 13067c478bd9Sstevel@tonic-gate int status; 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate for (i = 0; i < MAXCMDS; i++) 13097c478bd9Sstevel@tonic-gate if (fp == cmdproc[i].fp) break; 13107c478bd9Sstevel@tonic-gate if (i >= MAXCMDS) 13117c478bd9Sstevel@tonic-gate return (-1); 13127c478bd9Sstevel@tonic-gate (void) fclose(fp); 13137c478bd9Sstevel@tonic-gate cmdproc[i].fp = 0; 13147c478bd9Sstevel@tonic-gate pid = cmdproc[i].pid; 13157c478bd9Sstevel@tonic-gate while ((p = wait(&status)) != pid && p != (pid_t)-1); 13167c478bd9Sstevel@tonic-gate if (p == pid) { 13177c478bd9Sstevel@tonic-gate status = (status >> 8) & CMDERR; 13187c478bd9Sstevel@tonic-gate if (status == CMDERR) 13197c478bd9Sstevel@tonic-gate status = -1; 13207c478bd9Sstevel@tonic-gate } 13217c478bd9Sstevel@tonic-gate else 13227c478bd9Sstevel@tonic-gate status = -1; 13237c478bd9Sstevel@tonic-gate return (status); 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate /* 13277c478bd9Sstevel@tonic-gate * return pointer to the full path name of the shell 13287c478bd9Sstevel@tonic-gate * 13297c478bd9Sstevel@tonic-gate * SHELL is read from the environment and must start with / 13307c478bd9Sstevel@tonic-gate * 13317c478bd9Sstevel@tonic-gate * if set-uid or set-gid then the executable and its containing 13327c478bd9Sstevel@tonic-gate * directory must not be writable by the real user 13337c478bd9Sstevel@tonic-gate * 13347c478bd9Sstevel@tonic-gate * /usr/bin/sh is returned by default 13357c478bd9Sstevel@tonic-gate */ 13367c478bd9Sstevel@tonic-gate 13377c478bd9Sstevel@tonic-gate char * 13387c478bd9Sstevel@tonic-gate getshell() 13397c478bd9Sstevel@tonic-gate { 13407c478bd9Sstevel@tonic-gate char *s; 13417c478bd9Sstevel@tonic-gate char *sh; 13427c478bd9Sstevel@tonic-gate uid_t u; 13437c478bd9Sstevel@tonic-gate int j; 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate if (((sh = getenv("SHELL")) != 0) && *sh == '/') { 13467c478bd9Sstevel@tonic-gate if (u = getuid()) { 13477c478bd9Sstevel@tonic-gate if ((u != geteuid() || getgid() != getegid()) && 13487c478bd9Sstevel@tonic-gate !access(sh, 2)) 13497c478bd9Sstevel@tonic-gate goto defshell; 13507c478bd9Sstevel@tonic-gate s = strrchr(sh, '/'); 13517c478bd9Sstevel@tonic-gate *s = 0; 13527c478bd9Sstevel@tonic-gate j = access(sh, 2); 13537c478bd9Sstevel@tonic-gate *s = '/'; 13547c478bd9Sstevel@tonic-gate if (!j) goto defshell; 13557c478bd9Sstevel@tonic-gate } 13567c478bd9Sstevel@tonic-gate return (sh); 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate defshell: 13597c478bd9Sstevel@tonic-gate return ("/usr/bin/sh"); 13607c478bd9Sstevel@tonic-gate } 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate /* 13637c478bd9Sstevel@tonic-gate * the following functions implement the added "-ls" option 13647c478bd9Sstevel@tonic-gate */ 13657c478bd9Sstevel@tonic-gate 13667c478bd9Sstevel@tonic-gate #include <utmpx.h> 13677c478bd9Sstevel@tonic-gate #include <sys/mkdev.h> 13687c478bd9Sstevel@tonic-gate 13697c478bd9Sstevel@tonic-gate struct utmpx utmpx; 13707c478bd9Sstevel@tonic-gate #define NMAX (sizeof (utmpx.ut_name)) 13717c478bd9Sstevel@tonic-gate #define SCPYN(a, b) (void) strncpy(a, b, NMAX) 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate #define NUID 64 13747c478bd9Sstevel@tonic-gate #define NGID 64 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate static struct ncache { 13777c478bd9Sstevel@tonic-gate int id; 13787c478bd9Sstevel@tonic-gate char name[NMAX+1]; 13797c478bd9Sstevel@tonic-gate } nc[NUID], gc[NGID]; 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate /* 13827c478bd9Sstevel@tonic-gate * This function assumes that the password file is hashed 13837c478bd9Sstevel@tonic-gate * (or some such) to allow fast access based on a name key. 13847c478bd9Sstevel@tonic-gate */ 13857c478bd9Sstevel@tonic-gate static char * 13867c478bd9Sstevel@tonic-gate getname(uid_t uid) 13877c478bd9Sstevel@tonic-gate { 13887c478bd9Sstevel@tonic-gate struct passwd *pw; 13897c478bd9Sstevel@tonic-gate int cp; 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate #if (((NUID) & ((NUID) - 1)) != 0) 13927c478bd9Sstevel@tonic-gate cp = uid % (NUID); 13937c478bd9Sstevel@tonic-gate #else 13947c478bd9Sstevel@tonic-gate cp = uid & ((NUID) - 1); 13957c478bd9Sstevel@tonic-gate #endif 13967c478bd9Sstevel@tonic-gate if (uid >= 0 && nc[cp].id == uid && nc[cp].name[0]) 13977c478bd9Sstevel@tonic-gate return (nc[cp].name); 13987c478bd9Sstevel@tonic-gate pw = getpwuid(uid); 13997c478bd9Sstevel@tonic-gate if (!pw) 14007c478bd9Sstevel@tonic-gate return (0); 14017c478bd9Sstevel@tonic-gate nc[cp].id = uid; 14027c478bd9Sstevel@tonic-gate SCPYN(nc[cp].name, pw->pw_name); 14037c478bd9Sstevel@tonic-gate return (nc[cp].name); 14047c478bd9Sstevel@tonic-gate } 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate /* 14077c478bd9Sstevel@tonic-gate * This function assumes that the group file is hashed 14087c478bd9Sstevel@tonic-gate * (or some such) to allow fast access based on a name key. 14097c478bd9Sstevel@tonic-gate */ 14107c478bd9Sstevel@tonic-gate static char * 14117c478bd9Sstevel@tonic-gate getgroup(gid_t gid) 14127c478bd9Sstevel@tonic-gate { 14137c478bd9Sstevel@tonic-gate struct group *gr; 14147c478bd9Sstevel@tonic-gate int cp; 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate #if (((NGID) & ((NGID) - 1)) != 0) 14177c478bd9Sstevel@tonic-gate cp = gid % (NGID); 14187c478bd9Sstevel@tonic-gate #else 14197c478bd9Sstevel@tonic-gate cp = gid & ((NGID) - 1); 14207c478bd9Sstevel@tonic-gate #endif 14217c478bd9Sstevel@tonic-gate if (gid >= 0 && gc[cp].id == gid && gc[cp].name[0]) 14227c478bd9Sstevel@tonic-gate return (gc[cp].name); 14237c478bd9Sstevel@tonic-gate gr = getgrgid(gid); 14247c478bd9Sstevel@tonic-gate if (!gr) 14257c478bd9Sstevel@tonic-gate return (0); 14267c478bd9Sstevel@tonic-gate gc[cp].id = gid; 14277c478bd9Sstevel@tonic-gate SCPYN(gc[cp].name, gr->gr_name); 14287c478bd9Sstevel@tonic-gate return (gc[cp].name); 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate #define permoffset(who) ((who) * 3) 14327c478bd9Sstevel@tonic-gate #define permission(who, type) ((type) >> permoffset(who)) 14337c478bd9Sstevel@tonic-gate #define kbytes(bytes) (((bytes) + 1023) / 1024) 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate static int 14367c478bd9Sstevel@tonic-gate list(file, stp) 14377c478bd9Sstevel@tonic-gate char *file; 14387c478bd9Sstevel@tonic-gate struct stat *stp; 14397c478bd9Sstevel@tonic-gate { 14407c478bd9Sstevel@tonic-gate char pmode[32], uname[32], gname[32], fsize[32], ftime[32]; 1441fa9e4066Sahrens int trivial; 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * Each line below contains the relevant permission (column 1) and character 14457c478bd9Sstevel@tonic-gate * shown when the corresponding execute bit is either clear (column 2) 14467c478bd9Sstevel@tonic-gate * or set (column 3) 14477c478bd9Sstevel@tonic-gate * These permissions are as shown by ls(1b) 14487c478bd9Sstevel@tonic-gate */ 14497c478bd9Sstevel@tonic-gate static long special[] = { S_ISUID, 'S', 's', 14507c478bd9Sstevel@tonic-gate S_ISGID, 'S', 's', 14517c478bd9Sstevel@tonic-gate S_ISVTX, 'T', 't' }; 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate static time_t sixmonthsago = -1; 14547c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 14557c478bd9Sstevel@tonic-gate char flink[MAXPATHLEN + 1]; 14567c478bd9Sstevel@tonic-gate #endif 14577c478bd9Sstevel@tonic-gate int who; 14587c478bd9Sstevel@tonic-gate char *cp; 14597c478bd9Sstevel@tonic-gate char *tailname; 14607c478bd9Sstevel@tonic-gate time_t now; 14617c478bd9Sstevel@tonic-gate long long ksize; 14627c478bd9Sstevel@tonic-gate 14637c478bd9Sstevel@tonic-gate if (file == NULL || stp == NULL) 14647c478bd9Sstevel@tonic-gate return (-1); 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate (void) time(&now); 14677c478bd9Sstevel@tonic-gate if (sixmonthsago == -1) 14687c478bd9Sstevel@tonic-gate sixmonthsago = now - 6L*30L*24L*60L*60L; 14697c478bd9Sstevel@tonic-gate 14707c478bd9Sstevel@tonic-gate switch (stp->st_mode & S_IFMT) { 14717c478bd9Sstevel@tonic-gate #ifdef S_IFDIR 14727c478bd9Sstevel@tonic-gate case S_IFDIR: /* directory */ 14737c478bd9Sstevel@tonic-gate pmode[0] = 'd'; 14747c478bd9Sstevel@tonic-gate break; 14757c478bd9Sstevel@tonic-gate #endif 14767c478bd9Sstevel@tonic-gate #ifdef S_IFCHR 14777c478bd9Sstevel@tonic-gate case S_IFCHR: /* character special */ 14787c478bd9Sstevel@tonic-gate pmode[0] = 'c'; 14797c478bd9Sstevel@tonic-gate break; 14807c478bd9Sstevel@tonic-gate #endif 14817c478bd9Sstevel@tonic-gate #ifdef S_IFBLK 14827c478bd9Sstevel@tonic-gate case S_IFBLK: /* block special */ 14837c478bd9Sstevel@tonic-gate pmode[0] = 'b'; 14847c478bd9Sstevel@tonic-gate break; 14857c478bd9Sstevel@tonic-gate #endif 14867c478bd9Sstevel@tonic-gate #ifdef S_IFIFO 14877c478bd9Sstevel@tonic-gate case S_IFIFO: /* fifo special */ 14887c478bd9Sstevel@tonic-gate pmode[0] = 'p'; 14897c478bd9Sstevel@tonic-gate break; 14907c478bd9Sstevel@tonic-gate #endif 14917c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 14927c478bd9Sstevel@tonic-gate case S_IFLNK: /* symbolic link */ 14937c478bd9Sstevel@tonic-gate pmode[0] = 'l'; 14947c478bd9Sstevel@tonic-gate break; 14957c478bd9Sstevel@tonic-gate #endif 14967c478bd9Sstevel@tonic-gate #ifdef S_IFSOCK 14977c478bd9Sstevel@tonic-gate case S_IFSOCK: /* socket */ 14987c478bd9Sstevel@tonic-gate pmode[0] = 's'; 14997c478bd9Sstevel@tonic-gate break; 15007c478bd9Sstevel@tonic-gate #endif 15017c478bd9Sstevel@tonic-gate #ifdef S_IFDOOR 15027c478bd9Sstevel@tonic-gate case S_IFDOOR: /* door */ 15037c478bd9Sstevel@tonic-gate pmode[0] = 'D'; 15047c478bd9Sstevel@tonic-gate break; 15057c478bd9Sstevel@tonic-gate #endif 15067c478bd9Sstevel@tonic-gate #ifdef S_IFREG 15077c478bd9Sstevel@tonic-gate case S_IFREG: /* regular */ 15087c478bd9Sstevel@tonic-gate pmode[0] = '-'; 15097c478bd9Sstevel@tonic-gate break; 15107c478bd9Sstevel@tonic-gate #endif 15117c478bd9Sstevel@tonic-gate default: 15127c478bd9Sstevel@tonic-gate pmode[0] = '?'; 15137c478bd9Sstevel@tonic-gate break; 15147c478bd9Sstevel@tonic-gate } 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate for (who = 0; who < 3; who++) { 15177c478bd9Sstevel@tonic-gate int is_exec = stp->st_mode & permission(who, S_IEXEC)? 1 : 0; 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate if (stp->st_mode & permission(who, S_IREAD)) 15207c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = 'r'; 15217c478bd9Sstevel@tonic-gate else 15227c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = '-'; 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate if (stp->st_mode & permission(who, S_IWRITE)) 15257c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 2] = 'w'; 15267c478bd9Sstevel@tonic-gate else 15277c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 2] = '-'; 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate if (stp->st_mode & special[who * 3]) 15307c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 3] = 15317c478bd9Sstevel@tonic-gate special[who * 3 + 1 + is_exec]; 15327c478bd9Sstevel@tonic-gate else if (is_exec) 15337c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 3] = 'x'; 15347c478bd9Sstevel@tonic-gate else 15357c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 3] = '-'; 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate /* 15397c478bd9Sstevel@tonic-gate * Need to get the tail of the file name, since we have 15407c478bd9Sstevel@tonic-gate * already chdir()ed into the directory of the file 15417c478bd9Sstevel@tonic-gate */ 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate tailname = gettail(file); 15447c478bd9Sstevel@tonic-gate 1545fa9e4066Sahrens trivial = acl_trivial(tailname); 1546fa9e4066Sahrens if (trivial == -1) 1547fa9e4066Sahrens trivial = 0; 1548fa9e4066Sahrens 1549fa9e4066Sahrens if (trivial == 1) 15507c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = '+'; 15517c478bd9Sstevel@tonic-gate else 15527c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = ' '; 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 2] = '\0'; 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate /* 15577c478bd9Sstevel@tonic-gate * Prepare uname and gname. Always add a space afterwards 15587c478bd9Sstevel@tonic-gate * to keep columns from running together. 15597c478bd9Sstevel@tonic-gate */ 15607c478bd9Sstevel@tonic-gate cp = getname(stp->st_uid); 15617c478bd9Sstevel@tonic-gate if (cp != NULL) 15627c478bd9Sstevel@tonic-gate (void) sprintf(uname, "%-8s ", cp); 15637c478bd9Sstevel@tonic-gate else 15647c478bd9Sstevel@tonic-gate (void) sprintf(uname, "%-8ld ", stp->st_uid); 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate cp = getgroup(stp->st_gid); 15677c478bd9Sstevel@tonic-gate if (cp != NULL) 15687c478bd9Sstevel@tonic-gate (void) sprintf(gname, "%-8s ", cp); 15697c478bd9Sstevel@tonic-gate else 15707c478bd9Sstevel@tonic-gate (void) sprintf(gname, "%-8ld ", stp->st_gid); 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate if (pmode[0] == 'b' || pmode[0] == 'c') 15737c478bd9Sstevel@tonic-gate (void) sprintf(fsize, "%3ld,%4ld", 15747c478bd9Sstevel@tonic-gate major(stp->st_rdev), minor(stp->st_rdev)); 15757c478bd9Sstevel@tonic-gate else { 15767c478bd9Sstevel@tonic-gate (void) sprintf(fsize, (stp->st_size < 100000000) ? 15777c478bd9Sstevel@tonic-gate "%8lld" : "%lld", stp->st_size); 15787c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 15797c478bd9Sstevel@tonic-gate if (pmode[0] == 'l') { 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate who = readlink(tailname, flink, sizeof (flink) - 1); 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate if (who >= 0) 15857c478bd9Sstevel@tonic-gate flink[who] = '\0'; 15867c478bd9Sstevel@tonic-gate else 15877c478bd9Sstevel@tonic-gate flink[0] = '\0'; 15887c478bd9Sstevel@tonic-gate } 15897c478bd9Sstevel@tonic-gate #endif 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate 15927c478bd9Sstevel@tonic-gate cp = ctime(&stp->st_mtime); 15937c478bd9Sstevel@tonic-gate if (stp->st_mtime < sixmonthsago || stp->st_mtime > now) 15947c478bd9Sstevel@tonic-gate (void) sprintf(ftime, "%-7.7s %-4.4s", cp + 4, cp + 20); 15957c478bd9Sstevel@tonic-gate else 15967c478bd9Sstevel@tonic-gate (void) sprintf(ftime, "%-12.12s", cp + 4); 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate (void) printf((stp->st_ino < 100000) ? "%5llu " : 15997c478bd9Sstevel@tonic-gate "%llu ", stp->st_ino); /* inode # */ 16007c478bd9Sstevel@tonic-gate #ifdef S_IFSOCK 16017c478bd9Sstevel@tonic-gate ksize = (long long) kbytes(ldbtob(stp->st_blocks)); /* kbytes */ 16027c478bd9Sstevel@tonic-gate #else 16037c478bd9Sstevel@tonic-gate ksize = (long long) kbytes(stp->st_size); /* kbytes */ 16047c478bd9Sstevel@tonic-gate #endif 16057c478bd9Sstevel@tonic-gate (void) printf((ksize < 10000) ? "%4lld " : "%lld ", ksize); 16067c478bd9Sstevel@tonic-gate (void) printf("%s %2ld %s%s%s %s %s%s%s\n", 16077c478bd9Sstevel@tonic-gate pmode, /* protection */ 16087c478bd9Sstevel@tonic-gate stp->st_nlink, /* # of links */ 16097c478bd9Sstevel@tonic-gate uname, /* owner */ 16107c478bd9Sstevel@tonic-gate gname, /* group */ 16117c478bd9Sstevel@tonic-gate fsize, /* # of bytes */ 16127c478bd9Sstevel@tonic-gate ftime, /* modify time */ 16137c478bd9Sstevel@tonic-gate file, /* name */ 16147c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 16157c478bd9Sstevel@tonic-gate (pmode[0] == 'l') ? " -> " : "", 16167c478bd9Sstevel@tonic-gate (pmode[0] == 'l') ? flink : "" /* symlink */ 16177c478bd9Sstevel@tonic-gate #else 16187c478bd9Sstevel@tonic-gate "", 16197c478bd9Sstevel@tonic-gate "" 16207c478bd9Sstevel@tonic-gate #endif 16217c478bd9Sstevel@tonic-gate ); 16227c478bd9Sstevel@tonic-gate 16237c478bd9Sstevel@tonic-gate return (0); 16247c478bd9Sstevel@tonic-gate } 16257c478bd9Sstevel@tonic-gate 16267c478bd9Sstevel@tonic-gate static char * 16277c478bd9Sstevel@tonic-gate new_string(char *s) 16287c478bd9Sstevel@tonic-gate { 16297c478bd9Sstevel@tonic-gate char *p = strdup(s); 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate if (p) 16327c478bd9Sstevel@tonic-gate return (p); 16337c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); 16347c478bd9Sstevel@tonic-gate exit(1); 16357c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 16367c478bd9Sstevel@tonic-gate } 16377c478bd9Sstevel@tonic-gate 16387c478bd9Sstevel@tonic-gate /* 16397c478bd9Sstevel@tonic-gate * Read remote file system types from REMOTE_FS into the 16407c478bd9Sstevel@tonic-gate * remote_fstypes array. 16417c478bd9Sstevel@tonic-gate */ 16427c478bd9Sstevel@tonic-gate static void 16437c478bd9Sstevel@tonic-gate init_remote_fs() 16447c478bd9Sstevel@tonic-gate { 16457c478bd9Sstevel@tonic-gate FILE *fp; 16467c478bd9Sstevel@tonic-gate char line_buf[LINEBUF_SIZE]; 16477c478bd9Sstevel@tonic-gate 16487c478bd9Sstevel@tonic-gate if ((fp = fopen(REMOTE_FS, "r")) == NULL) { 16497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 16507c478bd9Sstevel@tonic-gate gettext("%s: Warning: can't open %s, ignored\n"), 16517c478bd9Sstevel@tonic-gate REMOTE_FS, cmdname); 16527c478bd9Sstevel@tonic-gate /* Use default string name for NFS */ 16537c478bd9Sstevel@tonic-gate remote_fstypes[fstype_index++] = "nfs"; 16547c478bd9Sstevel@tonic-gate return; 16557c478bd9Sstevel@tonic-gate } 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate while (fgets(line_buf, sizeof (line_buf), fp) != NULL) { 16587c478bd9Sstevel@tonic-gate char buf[LINEBUF_SIZE]; 16597c478bd9Sstevel@tonic-gate 16607c478bd9Sstevel@tonic-gate /* LINTED - unbounded string specifier */ 16617c478bd9Sstevel@tonic-gate (void) sscanf(line_buf, "%s", buf); 16627c478bd9Sstevel@tonic-gate remote_fstypes[fstype_index++] = new_string(buf); 16637c478bd9Sstevel@tonic-gate 16647c478bd9Sstevel@tonic-gate if (fstype_index == N_FSTYPES) 16657c478bd9Sstevel@tonic-gate break; 16667c478bd9Sstevel@tonic-gate } 16677c478bd9Sstevel@tonic-gate (void) fclose(fp); 16687c478bd9Sstevel@tonic-gate } 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate #define NPERM 30 /* Largest machine */ 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate /* 16737c478bd9Sstevel@tonic-gate * The PERM struct is the machine that builds permissions. The p_special 16747c478bd9Sstevel@tonic-gate * field contains what permissions need to be checked at run-time in 16757c478bd9Sstevel@tonic-gate * getmode(). This is one of 'X', 'u', 'g', or 'o'. It contains '\0' to 16767c478bd9Sstevel@tonic-gate * indicate normal processing. 16777c478bd9Sstevel@tonic-gate */ 16787c478bd9Sstevel@tonic-gate typedef struct PERMST { 16797c478bd9Sstevel@tonic-gate ushort_t p_who; /* Range of permission (e.g. ugo) */ 16807c478bd9Sstevel@tonic-gate ushort_t p_perm; /* Bits to turn on, off, assign */ 16817c478bd9Sstevel@tonic-gate uchar_t p_op; /* Operation: + - = */ 16827c478bd9Sstevel@tonic-gate uchar_t p_special; /* Special handling? */ 16837c478bd9Sstevel@tonic-gate } PERMST; 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate #ifndef S_ISVTX 16867c478bd9Sstevel@tonic-gate #define S_ISVTX 0 /* Not .1 */ 16877c478bd9Sstevel@tonic-gate #endif 16887c478bd9Sstevel@tonic-gate 16897c478bd9Sstevel@tonic-gate /* Mask values */ 16907c478bd9Sstevel@tonic-gate #define P_A (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO) /* allbits */ 16917c478bd9Sstevel@tonic-gate #define P_U (S_ISUID|S_ISVTX|S_IRWXU) /* user */ 16927c478bd9Sstevel@tonic-gate #define P_G (S_ISGID|S_ISVTX|S_IRWXG) /* group */ 16937c478bd9Sstevel@tonic-gate #define P_O (S_ISVTX|S_IRWXO) /* other */ 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate static int iswho(int c); 16967c478bd9Sstevel@tonic-gate static int isop(int c); 16977c478bd9Sstevel@tonic-gate static int isperm(PERMST *pp, int c); 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate static PERMST machine[NPERM]; /* Permission construction machine */ 17007c478bd9Sstevel@tonic-gate static PERMST *endp; /* Last used PERM structure */ 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate static uint_t nowho; /* No who for this mode (DOS kludge) */ 17037c478bd9Sstevel@tonic-gate 17047c478bd9Sstevel@tonic-gate /* 17057c478bd9Sstevel@tonic-gate * Read an ASCII string containing the symbolic/octal mode and 17067c478bd9Sstevel@tonic-gate * compile an automaton that recognizes it. The return value 17077c478bd9Sstevel@tonic-gate * is NULL if everything is OK, otherwise it is -1. 17087c478bd9Sstevel@tonic-gate */ 17097c478bd9Sstevel@tonic-gate static int 17107c478bd9Sstevel@tonic-gate readmode(ascmode) 17117c478bd9Sstevel@tonic-gate const char *ascmode; 17127c478bd9Sstevel@tonic-gate { 17137c478bd9Sstevel@tonic-gate const char *amode = ascmode; 17147c478bd9Sstevel@tonic-gate PERMST *pp; 17157c478bd9Sstevel@tonic-gate int seen_X; 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate nowho = 0; 17187c478bd9Sstevel@tonic-gate seen_X = 0; 17197c478bd9Sstevel@tonic-gate pp = &machine[0]; 17207c478bd9Sstevel@tonic-gate if (*amode >= '0' && *amode <= '7') { 17217c478bd9Sstevel@tonic-gate int mode; 17227c478bd9Sstevel@tonic-gate 17237c478bd9Sstevel@tonic-gate mode = 0; 17247c478bd9Sstevel@tonic-gate while (*amode >= '0' && *amode <= '7') 17257c478bd9Sstevel@tonic-gate mode = (mode<<3) + *amode++ - '0'; 17267c478bd9Sstevel@tonic-gate if (*amode != '\0') 17277c478bd9Sstevel@tonic-gate return (-1); 17287c478bd9Sstevel@tonic-gate #if S_ISUID != 04000 || S_ISGID != 02000 || \ 17297c478bd9Sstevel@tonic-gate S_IRUSR != 0400 || S_IWUSR != 0200 || S_IXUSR != 0100 || \ 17307c478bd9Sstevel@tonic-gate S_IRGRP != 0040 || S_IWGRP != 0020 || S_IXGRP != 0010 || \ 17317c478bd9Sstevel@tonic-gate S_IROTH != 0004 || S_IWOTH != 0002 || S_IXOTH != 0001 17327c478bd9Sstevel@tonic-gate /* 17337c478bd9Sstevel@tonic-gate * There is no requirement of the octal mode bits being 17347c478bd9Sstevel@tonic-gate * the same as the S_ macros. 17357c478bd9Sstevel@tonic-gate */ 17367c478bd9Sstevel@tonic-gate { 17377c478bd9Sstevel@tonic-gate mode_t mapping[] = { 17387c478bd9Sstevel@tonic-gate S_IXOTH, S_IWOTH, S_IROTH, 17397c478bd9Sstevel@tonic-gate S_IXGRP, S_IWGRP, S_IRGRP, 17407c478bd9Sstevel@tonic-gate S_IXUSR, S_IWUSR, S_IRUSR, 17417c478bd9Sstevel@tonic-gate S_ISGID, S_ISUID, 17427c478bd9Sstevel@tonic-gate 0 17437c478bd9Sstevel@tonic-gate }; 17447c478bd9Sstevel@tonic-gate int i, newmode = 0; 17457c478bd9Sstevel@tonic-gate 17467c478bd9Sstevel@tonic-gate for (i = 0; mapping[i] != 0; i++) 17477c478bd9Sstevel@tonic-gate if (mode & (1<<i)) 17487c478bd9Sstevel@tonic-gate newmode |= mapping[i]; 17497c478bd9Sstevel@tonic-gate mode = newmode; 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate #endif 17527c478bd9Sstevel@tonic-gate pp->p_who = P_A; 17537c478bd9Sstevel@tonic-gate pp->p_perm = mode; 17547c478bd9Sstevel@tonic-gate pp->p_op = '='; 17557c478bd9Sstevel@tonic-gate } else for (;;) { 17567c478bd9Sstevel@tonic-gate int t; 17577c478bd9Sstevel@tonic-gate int who = 0; 17587c478bd9Sstevel@tonic-gate 17597c478bd9Sstevel@tonic-gate while ((t = iswho(*amode)) != 0) { 17607c478bd9Sstevel@tonic-gate ++amode; 17617c478bd9Sstevel@tonic-gate who |= t; 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate if (who == 0) { 17647c478bd9Sstevel@tonic-gate mode_t currmask; 17657c478bd9Sstevel@tonic-gate (void) umask(currmask = umask((mode_t)0)); 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate /* 17687c478bd9Sstevel@tonic-gate * If no who specified, must use contents of 17697c478bd9Sstevel@tonic-gate * umask to determine which bits to flip. This 17707c478bd9Sstevel@tonic-gate * is POSIX/V7/BSD behaviour, but not SVID. 17717c478bd9Sstevel@tonic-gate */ 17727c478bd9Sstevel@tonic-gate who = (~currmask)&P_A; 17737c478bd9Sstevel@tonic-gate ++nowho; 17747c478bd9Sstevel@tonic-gate } else 17757c478bd9Sstevel@tonic-gate nowho = 0; 17767c478bd9Sstevel@tonic-gate samewho: 17777c478bd9Sstevel@tonic-gate if (!isop(pp->p_op = *amode++)) 17787c478bd9Sstevel@tonic-gate return (-1); 17797c478bd9Sstevel@tonic-gate pp->p_perm = 0; 17807c478bd9Sstevel@tonic-gate pp->p_special = 0; 17817c478bd9Sstevel@tonic-gate while ((t = isperm(pp, *amode)) != 0) { 17827c478bd9Sstevel@tonic-gate if (pp->p_special == 'X') { 17837c478bd9Sstevel@tonic-gate seen_X = 1; 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate if (pp->p_perm != 0) { 17867c478bd9Sstevel@tonic-gate ushort_t op; 17877c478bd9Sstevel@tonic-gate 17887c478bd9Sstevel@tonic-gate /* 17897c478bd9Sstevel@tonic-gate * Remember the 'who' for the previous 17907c478bd9Sstevel@tonic-gate * transformation. 17917c478bd9Sstevel@tonic-gate */ 17927c478bd9Sstevel@tonic-gate pp->p_who = who; 17937c478bd9Sstevel@tonic-gate pp->p_special = 0; 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate op = pp->p_op; 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate /* Keep 'X' separate */ 17987c478bd9Sstevel@tonic-gate ++pp; 17997c478bd9Sstevel@tonic-gate pp->p_special = 'X'; 18007c478bd9Sstevel@tonic-gate pp->p_op = op; 18017c478bd9Sstevel@tonic-gate } 18027c478bd9Sstevel@tonic-gate } else if (seen_X) { 18037c478bd9Sstevel@tonic-gate ushort_t op; 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate /* Remember the 'who' for the X */ 18067c478bd9Sstevel@tonic-gate pp->p_who = who; 18077c478bd9Sstevel@tonic-gate 18087c478bd9Sstevel@tonic-gate op = pp->p_op; 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate /* Keep 'X' separate */ 18117c478bd9Sstevel@tonic-gate ++pp; 18127c478bd9Sstevel@tonic-gate pp->p_perm = 0; 18137c478bd9Sstevel@tonic-gate pp->p_special = 0; 18147c478bd9Sstevel@tonic-gate pp->p_op = op; 18157c478bd9Sstevel@tonic-gate } 18167c478bd9Sstevel@tonic-gate ++amode; 18177c478bd9Sstevel@tonic-gate pp->p_perm |= t; 18187c478bd9Sstevel@tonic-gate } 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate /* 18217c478bd9Sstevel@tonic-gate * These returned 0, but were actually parsed, so 18227c478bd9Sstevel@tonic-gate * don't look at them again. 18237c478bd9Sstevel@tonic-gate */ 18247c478bd9Sstevel@tonic-gate switch (pp->p_special) { 18257c478bd9Sstevel@tonic-gate case 'u': 18267c478bd9Sstevel@tonic-gate case 'g': 18277c478bd9Sstevel@tonic-gate case 'o': 18287c478bd9Sstevel@tonic-gate ++amode; 18297c478bd9Sstevel@tonic-gate break; 18307c478bd9Sstevel@tonic-gate } 18317c478bd9Sstevel@tonic-gate pp->p_who = who; 18327c478bd9Sstevel@tonic-gate switch (*amode) { 18337c478bd9Sstevel@tonic-gate case '\0': 18347c478bd9Sstevel@tonic-gate break; 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate case ',': 18377c478bd9Sstevel@tonic-gate ++amode; 18387c478bd9Sstevel@tonic-gate ++pp; 18397c478bd9Sstevel@tonic-gate continue; 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate default: 18427c478bd9Sstevel@tonic-gate ++pp; 18437c478bd9Sstevel@tonic-gate goto samewho; 18447c478bd9Sstevel@tonic-gate } 18457c478bd9Sstevel@tonic-gate break; 18467c478bd9Sstevel@tonic-gate } 18477c478bd9Sstevel@tonic-gate endp = pp; 18487c478bd9Sstevel@tonic-gate return (NULL); 18497c478bd9Sstevel@tonic-gate } 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate /* 18527c478bd9Sstevel@tonic-gate * Given a character from the mode, return the associated 18537c478bd9Sstevel@tonic-gate * value as who (user designation) mask or 0 if this isn't valid. 18547c478bd9Sstevel@tonic-gate */ 18557c478bd9Sstevel@tonic-gate static int 18567c478bd9Sstevel@tonic-gate iswho(c) 18577c478bd9Sstevel@tonic-gate int c; 18587c478bd9Sstevel@tonic-gate { 18597c478bd9Sstevel@tonic-gate switch (c) { 18607c478bd9Sstevel@tonic-gate case 'a': 18617c478bd9Sstevel@tonic-gate return (P_A); 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate case 'u': 18647c478bd9Sstevel@tonic-gate return (P_U); 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate case 'g': 18677c478bd9Sstevel@tonic-gate return (P_G); 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate case 'o': 18707c478bd9Sstevel@tonic-gate return (P_O); 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate default: 18737c478bd9Sstevel@tonic-gate return (0); 18747c478bd9Sstevel@tonic-gate } 18757c478bd9Sstevel@tonic-gate /* NOTREACHED */ 18767c478bd9Sstevel@tonic-gate } 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate /* 18797c478bd9Sstevel@tonic-gate * Return non-zero if this is a valid op code 18807c478bd9Sstevel@tonic-gate * in a symbolic mode. 18817c478bd9Sstevel@tonic-gate */ 18827c478bd9Sstevel@tonic-gate static int 18837c478bd9Sstevel@tonic-gate isop(c) 18847c478bd9Sstevel@tonic-gate int c; 18857c478bd9Sstevel@tonic-gate { 18867c478bd9Sstevel@tonic-gate switch (c) { 18877c478bd9Sstevel@tonic-gate case '+': 18887c478bd9Sstevel@tonic-gate case '-': 18897c478bd9Sstevel@tonic-gate case '=': 18907c478bd9Sstevel@tonic-gate return (1); 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate default: 18937c478bd9Sstevel@tonic-gate return (0); 18947c478bd9Sstevel@tonic-gate } 18957c478bd9Sstevel@tonic-gate /* NOTREACHED */ 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate 18987c478bd9Sstevel@tonic-gate /* 18997c478bd9Sstevel@tonic-gate * Return the permission bits implied by this character or 0 19007c478bd9Sstevel@tonic-gate * if it isn't valid. Also returns 0 when the pseudo-permissions 'u', 'g', or 19017c478bd9Sstevel@tonic-gate * 'o' are used, and sets pp->p_special to the one used. 19027c478bd9Sstevel@tonic-gate */ 19037c478bd9Sstevel@tonic-gate static int 19047c478bd9Sstevel@tonic-gate isperm(pp, c) 19057c478bd9Sstevel@tonic-gate PERMST *pp; 19067c478bd9Sstevel@tonic-gate int c; 19077c478bd9Sstevel@tonic-gate { 19087c478bd9Sstevel@tonic-gate switch (c) { 19097c478bd9Sstevel@tonic-gate case 'u': 19107c478bd9Sstevel@tonic-gate case 'g': 19117c478bd9Sstevel@tonic-gate case 'o': 19127c478bd9Sstevel@tonic-gate pp->p_special = c; 19137c478bd9Sstevel@tonic-gate return (0); 19147c478bd9Sstevel@tonic-gate 19157c478bd9Sstevel@tonic-gate case 'r': 19167c478bd9Sstevel@tonic-gate return (S_IRUSR|S_IRGRP|S_IROTH); 19177c478bd9Sstevel@tonic-gate 19187c478bd9Sstevel@tonic-gate case 'w': 19197c478bd9Sstevel@tonic-gate return (S_IWUSR|S_IWGRP|S_IWOTH); 19207c478bd9Sstevel@tonic-gate 19217c478bd9Sstevel@tonic-gate case 'x': 19227c478bd9Sstevel@tonic-gate return (S_IXUSR|S_IXGRP|S_IXOTH); 19237c478bd9Sstevel@tonic-gate 19247c478bd9Sstevel@tonic-gate #if S_ISVTX != 0 19257c478bd9Sstevel@tonic-gate case 't': 19267c478bd9Sstevel@tonic-gate return (S_ISVTX); 19277c478bd9Sstevel@tonic-gate #endif 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate case 'X': 19307c478bd9Sstevel@tonic-gate pp->p_special = 'X'; 19317c478bd9Sstevel@tonic-gate return (S_IXUSR|S_IXGRP|S_IXOTH); 19327c478bd9Sstevel@tonic-gate 19337c478bd9Sstevel@tonic-gate #if S_ISVTX != 0 19347c478bd9Sstevel@tonic-gate case 'a': 19357c478bd9Sstevel@tonic-gate return (S_ISVTX); 19367c478bd9Sstevel@tonic-gate #endif 19377c478bd9Sstevel@tonic-gate 19387c478bd9Sstevel@tonic-gate case 'h': 19397c478bd9Sstevel@tonic-gate return (S_ISUID); 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate /* 19427c478bd9Sstevel@tonic-gate * This change makes: 19437c478bd9Sstevel@tonic-gate * chmod +s file 19447c478bd9Sstevel@tonic-gate * set the system bit on dos but means that 19457c478bd9Sstevel@tonic-gate * chmod u+s file 19467c478bd9Sstevel@tonic-gate * chmod g+s file 19477c478bd9Sstevel@tonic-gate * chmod a+s file 19487c478bd9Sstevel@tonic-gate * are all like UNIX. 19497c478bd9Sstevel@tonic-gate */ 19507c478bd9Sstevel@tonic-gate case 's': 19517c478bd9Sstevel@tonic-gate return (nowho ? S_ISGID : S_ISGID|S_ISUID); 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate default: 19547c478bd9Sstevel@tonic-gate return (0); 19557c478bd9Sstevel@tonic-gate } 19567c478bd9Sstevel@tonic-gate /* NOTREACHED */ 19577c478bd9Sstevel@tonic-gate } 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate /* 19607c478bd9Sstevel@tonic-gate * Execute the automaton that is created by readmode() 19617c478bd9Sstevel@tonic-gate * to generate the final mode that will be used. This 19627c478bd9Sstevel@tonic-gate * code is passed a starting mode that is usually the original 19637c478bd9Sstevel@tonic-gate * mode of the file being changed (or 0). Note that this mode must contain 19647c478bd9Sstevel@tonic-gate * the file-type bits as well, so that S_ISDIR will succeed on directories. 19657c478bd9Sstevel@tonic-gate */ 19667c478bd9Sstevel@tonic-gate static mode_t 19677c478bd9Sstevel@tonic-gate getmode(mode_t startmode) 19687c478bd9Sstevel@tonic-gate { 19697c478bd9Sstevel@tonic-gate PERMST *pp; 19707c478bd9Sstevel@tonic-gate mode_t temp; 19717c478bd9Sstevel@tonic-gate mode_t perm; 19727c478bd9Sstevel@tonic-gate 19737c478bd9Sstevel@tonic-gate for (pp = &machine[0]; pp <= endp; ++pp) { 19747c478bd9Sstevel@tonic-gate perm = (mode_t)0; 19757c478bd9Sstevel@tonic-gate /* 19767c478bd9Sstevel@tonic-gate * For the special modes 'u', 'g' and 'o', the named portion 19777c478bd9Sstevel@tonic-gate * of the mode refers to after the previous clause has been 19787c478bd9Sstevel@tonic-gate * processed, while the 'X' mode refers to the contents of the 19797c478bd9Sstevel@tonic-gate * mode before any clauses have been processed. 19807c478bd9Sstevel@tonic-gate * 19817c478bd9Sstevel@tonic-gate * References: P1003.2/D11.2, Section 4.7.7, 19827c478bd9Sstevel@tonic-gate * lines 2568-2570, 2578-2583 19837c478bd9Sstevel@tonic-gate */ 19847c478bd9Sstevel@tonic-gate switch (pp->p_special) { 19857c478bd9Sstevel@tonic-gate case 'u': 19867c478bd9Sstevel@tonic-gate temp = startmode & S_IRWXU; 19877c478bd9Sstevel@tonic-gate if (temp & (S_IRUSR|S_IRGRP|S_IROTH)) 19887c478bd9Sstevel@tonic-gate perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & 19897c478bd9Sstevel@tonic-gate pp->p_who); 19907c478bd9Sstevel@tonic-gate if (temp & (S_IWUSR|S_IWGRP|S_IWOTH)) 19917c478bd9Sstevel@tonic-gate perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who); 19927c478bd9Sstevel@tonic-gate if (temp & (S_IXUSR|S_IXGRP|S_IXOTH)) 19937c478bd9Sstevel@tonic-gate perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who); 19947c478bd9Sstevel@tonic-gate break; 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate case 'g': 19977c478bd9Sstevel@tonic-gate temp = startmode & S_IRWXG; 19987c478bd9Sstevel@tonic-gate if (temp & (S_IRUSR|S_IRGRP|S_IROTH)) 19997c478bd9Sstevel@tonic-gate perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & pp->p_who); 20007c478bd9Sstevel@tonic-gate if (temp & (S_IWUSR|S_IWGRP|S_IWOTH)) 20017c478bd9Sstevel@tonic-gate perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who); 20027c478bd9Sstevel@tonic-gate if (temp & (S_IXUSR|S_IXGRP|S_IXOTH)) 20037c478bd9Sstevel@tonic-gate perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who); 20047c478bd9Sstevel@tonic-gate break; 20057c478bd9Sstevel@tonic-gate 20067c478bd9Sstevel@tonic-gate case 'o': 20077c478bd9Sstevel@tonic-gate temp = startmode & S_IRWXO; 20087c478bd9Sstevel@tonic-gate if (temp & (S_IRUSR|S_IRGRP|S_IROTH)) 20097c478bd9Sstevel@tonic-gate perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & pp->p_who); 20107c478bd9Sstevel@tonic-gate if (temp & (S_IWUSR|S_IWGRP|S_IWOTH)) 20117c478bd9Sstevel@tonic-gate perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who); 20127c478bd9Sstevel@tonic-gate if (temp & (S_IXUSR|S_IXGRP|S_IXOTH)) 20137c478bd9Sstevel@tonic-gate perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who); 20147c478bd9Sstevel@tonic-gate break; 20157c478bd9Sstevel@tonic-gate 20167c478bd9Sstevel@tonic-gate case 'X': 20177c478bd9Sstevel@tonic-gate perm = pp->p_perm; 20187c478bd9Sstevel@tonic-gate break; 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate default: 20217c478bd9Sstevel@tonic-gate perm = pp->p_perm; 20227c478bd9Sstevel@tonic-gate break; 20237c478bd9Sstevel@tonic-gate } 20247c478bd9Sstevel@tonic-gate switch (pp->p_op) { 20257c478bd9Sstevel@tonic-gate case '-': 20267c478bd9Sstevel@tonic-gate startmode &= ~(perm & pp->p_who); 20277c478bd9Sstevel@tonic-gate break; 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate case '=': 20307c478bd9Sstevel@tonic-gate startmode &= ~pp->p_who; 20317c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 20327c478bd9Sstevel@tonic-gate case '+': 20337c478bd9Sstevel@tonic-gate startmode |= (perm & pp->p_who); 20347c478bd9Sstevel@tonic-gate break; 20357c478bd9Sstevel@tonic-gate } 20367c478bd9Sstevel@tonic-gate } 20377c478bd9Sstevel@tonic-gate return (startmode); 20387c478bd9Sstevel@tonic-gate } 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate /* 20417c478bd9Sstevel@tonic-gate * Returns the last component of a path name, unless it is 20427c478bd9Sstevel@tonic-gate * an absolute path, in which case it returns the whole path 20437c478bd9Sstevel@tonic-gate */ 20447c478bd9Sstevel@tonic-gate static char 20457c478bd9Sstevel@tonic-gate *gettail(char *fname) 20467c478bd9Sstevel@tonic-gate { 20477c478bd9Sstevel@tonic-gate char *base = fname; 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate if (*fname != '/') { 20507c478bd9Sstevel@tonic-gate if ((base = strrchr(fname, '/')) != NULL) 20517c478bd9Sstevel@tonic-gate base++; 20527c478bd9Sstevel@tonic-gate else 20537c478bd9Sstevel@tonic-gate base = fname; 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate return (base); 20567c478bd9Sstevel@tonic-gate } 2057