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