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