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