17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5d35170d6Srm * Common Development and Distribution License (the "License"). 6d35170d6Srm * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22ef497ae3SRich Burridge * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 2303f45afcSYuri Pankov * Copyright 2012 Nexenta Systems, Inc. All rights reserved. 24*05f32410SAndy Stormont * Copyright (c) 2013 Andrew Stormont. All rights reserved. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 27da1a9cbeSjonb 287c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 297c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate /* Parts of this product may be derived from */ 337c478bd9Sstevel@tonic-gate /* Mortice Kern Systems Inc. and Berkeley 4.3 BSD systems. */ 347c478bd9Sstevel@tonic-gate /* licensed from Mortice Kern Systems Inc. and */ 357c478bd9Sstevel@tonic-gate /* the University of California. */ 367c478bd9Sstevel@tonic-gate 377c478bd9Sstevel@tonic-gate /* 387c478bd9Sstevel@tonic-gate * Copyright 1985, 1990 by Mortice Kern Systems Inc. All rights reserved. 397c478bd9Sstevel@tonic-gate */ 407c478bd9Sstevel@tonic-gate 417c478bd9Sstevel@tonic-gate #include <stdio.h> 427c478bd9Sstevel@tonic-gate #include <errno.h> 437c478bd9Sstevel@tonic-gate #include <pwd.h> 447c478bd9Sstevel@tonic-gate #include <grp.h> 457c478bd9Sstevel@tonic-gate #include <sys/types.h> 467c478bd9Sstevel@tonic-gate #include <sys/stat.h> 477c478bd9Sstevel@tonic-gate #include <sys/param.h> 487c478bd9Sstevel@tonic-gate #include <sys/acl.h> 497c478bd9Sstevel@tonic-gate #include <limits.h> 507c478bd9Sstevel@tonic-gate #include <unistd.h> 517c478bd9Sstevel@tonic-gate #include <stdlib.h> 527c478bd9Sstevel@tonic-gate #include <locale.h> 537c478bd9Sstevel@tonic-gate #include <string.h> 547c478bd9Sstevel@tonic-gate #include <strings.h> 557c478bd9Sstevel@tonic-gate #include <ctype.h> 567c478bd9Sstevel@tonic-gate #include <wait.h> 577c478bd9Sstevel@tonic-gate #include <fnmatch.h> 587c478bd9Sstevel@tonic-gate #include <langinfo.h> 597c478bd9Sstevel@tonic-gate #include <ftw.h> 609ab6dc39Schin #include <libgen.h> 61b34cd89aSYuri Pankov #include <err.h> 62b34cd89aSYuri Pankov #include <regex.h> 633d63ea05Sas #include "getresponse.h" 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate #define A_DAY (long)(60*60*24) /* a day full of seconds */ 66da1a9cbeSjonb #define A_MIN (long)(60) 677c478bd9Sstevel@tonic-gate #define BLKSIZ 512 687c478bd9Sstevel@tonic-gate #define round(x, s) (((x)+(s)-1)&~((s)-1)) 697c478bd9Sstevel@tonic-gate #ifndef FTW_SLN 707c478bd9Sstevel@tonic-gate #define FTW_SLN 7 717c478bd9Sstevel@tonic-gate #endif 727c478bd9Sstevel@tonic-gate #define LINEBUF_SIZE LINE_MAX /* input or output lines */ 737c478bd9Sstevel@tonic-gate #define REMOTE_FS "/etc/dfs/fstypes" 747c478bd9Sstevel@tonic-gate #define N_FSTYPES 20 75d35170d6Srm #define SHELL_MAXARGS 253 /* see doexec() for description */ 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate /* 787c478bd9Sstevel@tonic-gate * This is the list of operations 797c478bd9Sstevel@tonic-gate * F_USER and F_GROUP are named to avoid conflict with USER and GROUP defined 807c478bd9Sstevel@tonic-gate * in sys/acl.h 817c478bd9Sstevel@tonic-gate */ 827c478bd9Sstevel@tonic-gate 837c478bd9Sstevel@tonic-gate enum Command 847c478bd9Sstevel@tonic-gate { 85b34cd89aSYuri Pankov PRINT, 86b34cd89aSYuri Pankov ACL, AMIN, AND, ATIME, CMIN, CPIO, CSIZE, CTIME, DEPTH, EXEC, F_GROUP, 87*05f32410SAndy Stormont F_GROUPACL, F_USER, F_USERACL, FOLLOW, FSTYPE, INAME, INUM, IPATH, 88*05f32410SAndy Stormont IREGEX, LINKS, LOCAL, LPAREN, LS, MAXDEPTH, MINDEPTH, MMIN, MOUNT, 89*05f32410SAndy Stormont MTIME, NAME, NCPIO, NEWER, NOGRP, NOT, NOUSER, OK, OR, PATH, PERM, 90*05f32410SAndy Stormont PRINT0, PRUNE, REGEX, RPAREN, SIZE, TYPE, VARARGS, XATTR 917c478bd9Sstevel@tonic-gate }; 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate enum Type 947c478bd9Sstevel@tonic-gate { 957c478bd9Sstevel@tonic-gate Unary, Id, Num, Str, Exec, Cpio, Op 967c478bd9Sstevel@tonic-gate }; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate struct Args 997c478bd9Sstevel@tonic-gate { 1007c478bd9Sstevel@tonic-gate char name[10]; 1017c478bd9Sstevel@tonic-gate enum Command action; 1027c478bd9Sstevel@tonic-gate enum Type type; 1037c478bd9Sstevel@tonic-gate }; 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate /* 1067c478bd9Sstevel@tonic-gate * Except for pathnames, these are the only legal arguments 1077c478bd9Sstevel@tonic-gate */ 1087c478bd9Sstevel@tonic-gate static struct Args commands[] = 1097c478bd9Sstevel@tonic-gate { 110b34cd89aSYuri Pankov "!", NOT, Op, 111b34cd89aSYuri Pankov "(", LPAREN, Unary, 112b34cd89aSYuri Pankov ")", RPAREN, Unary, 113b34cd89aSYuri Pankov "-a", AND, Op, 114b34cd89aSYuri Pankov "-acl", ACL, Unary, 115b34cd89aSYuri Pankov "-amin", AMIN, Num, 116b34cd89aSYuri Pankov "-and", AND, Op, 117b34cd89aSYuri Pankov "-atime", ATIME, Num, 118b34cd89aSYuri Pankov "-cmin", CMIN, Num, 119b34cd89aSYuri Pankov "-cpio", CPIO, Cpio, 120b34cd89aSYuri Pankov "-ctime", CTIME, Num, 121b34cd89aSYuri Pankov "-depth", DEPTH, Unary, 122b34cd89aSYuri Pankov "-exec", EXEC, Exec, 123b34cd89aSYuri Pankov "-follow", FOLLOW, Unary, 124b34cd89aSYuri Pankov "-fstype", FSTYPE, Str, 1257c478bd9Sstevel@tonic-gate "-group", F_GROUP, Num, 126b34cd89aSYuri Pankov "-groupacl", F_GROUPACL, Num, 127b34cd89aSYuri Pankov "-iname", INAME, Str, 128b34cd89aSYuri Pankov "-inum", INUM, Num, 129*05f32410SAndy Stormont "-ipath", IPATH, Str, 130b34cd89aSYuri Pankov "-iregex", IREGEX, Str, 13103f45afcSYuri Pankov "-links", LINKS, Num, 13203f45afcSYuri Pankov "-local", LOCAL, Unary, 133b34cd89aSYuri Pankov "-ls", LS, Unary, 134b34cd89aSYuri Pankov "-maxdepth", MAXDEPTH, Num, 135b34cd89aSYuri Pankov "-mindepth", MINDEPTH, Num, 136b34cd89aSYuri Pankov "-mmin", MMIN, Num, 137b34cd89aSYuri Pankov "-mount", MOUNT, Unary, 138b34cd89aSYuri Pankov "-mtime", MTIME, Num, 139b34cd89aSYuri Pankov "-name", NAME, Str, 140b34cd89aSYuri Pankov "-ncpio", NCPIO, Cpio, 141b34cd89aSYuri Pankov "-newer", NEWER, Str, 142b34cd89aSYuri Pankov "-nogroup", NOGRP, Unary, 143b34cd89aSYuri Pankov "-not", NOT, Op, 144b34cd89aSYuri Pankov "-nouser", NOUSER, Unary, 145b34cd89aSYuri Pankov "-o", OR, Op, 146b34cd89aSYuri Pankov "-ok", OK, Exec, 147b34cd89aSYuri Pankov "-or", OR, Op, 148*05f32410SAndy Stormont "-path", PATH, Str, 149b34cd89aSYuri Pankov "-perm", PERM, Num, 150b34cd89aSYuri Pankov "-print", PRINT, Unary, 151b34cd89aSYuri Pankov "-print0", PRINT0, Unary, 152b34cd89aSYuri Pankov "-prune", PRUNE, Unary, 153b34cd89aSYuri Pankov "-regex", REGEX, Str, 154b34cd89aSYuri Pankov "-size", SIZE, Num, 155b34cd89aSYuri Pankov "-type", TYPE, Num, 156b34cd89aSYuri Pankov "-user", F_USER, Num, 157b34cd89aSYuri Pankov "-useracl", F_USERACL, Num, 158b34cd89aSYuri Pankov "-xattr", XATTR, Unary, 159b34cd89aSYuri Pankov "-xdev", MOUNT, Unary, 160b34cd89aSYuri Pankov NULL, 0, 0 1617c478bd9Sstevel@tonic-gate }; 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate union Item 1647c478bd9Sstevel@tonic-gate { 1657c478bd9Sstevel@tonic-gate struct Node *np; 1667c478bd9Sstevel@tonic-gate struct Arglist *vp; 1677c478bd9Sstevel@tonic-gate time_t t; 1687c478bd9Sstevel@tonic-gate char *cp; 1697c478bd9Sstevel@tonic-gate char **ap; 1707c478bd9Sstevel@tonic-gate long l; 1717c478bd9Sstevel@tonic-gate int i; 1727c478bd9Sstevel@tonic-gate long long ll; 1737c478bd9Sstevel@tonic-gate }; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate struct Node 1767c478bd9Sstevel@tonic-gate { 1777c478bd9Sstevel@tonic-gate struct Node *next; 1787c478bd9Sstevel@tonic-gate enum Command action; 1797c478bd9Sstevel@tonic-gate enum Type type; 1807c478bd9Sstevel@tonic-gate union Item first; 1817c478bd9Sstevel@tonic-gate union Item second; 1827c478bd9Sstevel@tonic-gate }; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate /* if no -print, -exec or -ok replace "expression" with "(expression) -print" */ 1857c478bd9Sstevel@tonic-gate static struct Node PRINT_NODE = { 0, PRINT, 0, 0}; 1867c478bd9Sstevel@tonic-gate static struct Node LPAREN_NODE = { 0, LPAREN, 0, 0}; 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate /* 1907c478bd9Sstevel@tonic-gate * Prototype variable size arglist buffer 1917c478bd9Sstevel@tonic-gate */ 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate struct Arglist 1947c478bd9Sstevel@tonic-gate { 1957c478bd9Sstevel@tonic-gate struct Arglist *next; 1967c478bd9Sstevel@tonic-gate char *end; 1977c478bd9Sstevel@tonic-gate char *nextstr; 1987c478bd9Sstevel@tonic-gate char **firstvar; 1997c478bd9Sstevel@tonic-gate char **nextvar; 2007c478bd9Sstevel@tonic-gate char *arglist[1]; 2017c478bd9Sstevel@tonic-gate }; 2027c478bd9Sstevel@tonic-gate 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate static int compile(); 2057c478bd9Sstevel@tonic-gate static int execute(); 206d35170d6Srm static int doexec(char *, char **, int *); 2077c478bd9Sstevel@tonic-gate static struct Args *lookup(); 2087c478bd9Sstevel@tonic-gate static int ok(); 2096c83d09fSrobbin static void usage(void) __NORETURN; 2107c478bd9Sstevel@tonic-gate static struct Arglist *varargs(); 2117c478bd9Sstevel@tonic-gate static int list(); 2127c478bd9Sstevel@tonic-gate static char *getgroup(); 2137c478bd9Sstevel@tonic-gate static FILE *cmdopen(); 2147c478bd9Sstevel@tonic-gate static int cmdclose(); 2157c478bd9Sstevel@tonic-gate static char *getshell(); 2167c478bd9Sstevel@tonic-gate static void init_remote_fs(); 2177c478bd9Sstevel@tonic-gate static char *getname(); 2187c478bd9Sstevel@tonic-gate static int readmode(); 2197c478bd9Sstevel@tonic-gate static mode_t getmode(); 2207c478bd9Sstevel@tonic-gate static char *gettail(); 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate 22368a94df1Scf static int walkflags = FTW_CHDIR|FTW_PHYS|FTW_ANYERR|FTW_NOLOOP; 2247c478bd9Sstevel@tonic-gate static struct Node *topnode; 2257c478bd9Sstevel@tonic-gate static struct Node *freenode; /* next free node we may use later */ 2267c478bd9Sstevel@tonic-gate static char *cpio[] = { "cpio", "-o", 0 }; 2277c478bd9Sstevel@tonic-gate static char *ncpio[] = { "cpio", "-oc", 0 }; 2287c478bd9Sstevel@tonic-gate static char *cpiol[] = { "cpio", "-oL", 0 }; 2297c478bd9Sstevel@tonic-gate static char *ncpiol[] = { "cpio", "-ocL", 0 }; 2307c478bd9Sstevel@tonic-gate static time_t now; 2317c478bd9Sstevel@tonic-gate static FILE *output; 2327c478bd9Sstevel@tonic-gate static char *dummyarg = (char *)-1; 2337c478bd9Sstevel@tonic-gate static int lastval; 2347c478bd9Sstevel@tonic-gate static int varsize; 2357c478bd9Sstevel@tonic-gate static struct Arglist *lastlist; 2367c478bd9Sstevel@tonic-gate static char *cmdname; 2377c478bd9Sstevel@tonic-gate static char *remote_fstypes[N_FSTYPES+1]; 2387c478bd9Sstevel@tonic-gate static int fstype_index = 0; 2397c478bd9Sstevel@tonic-gate static int action_expression = 0; /* -print, -exec, or -ok */ 2407c478bd9Sstevel@tonic-gate static int error = 0; 2417c478bd9Sstevel@tonic-gate static int paren_cnt = 0; /* keeps track of parentheses */ 242b34cd89aSYuri Pankov static int Eflag = 0; 2437c478bd9Sstevel@tonic-gate static int hflag = 0; 2447c478bd9Sstevel@tonic-gate static int lflag = 0; 245d35170d6Srm /* set when doexec()-invoked utility returns non-zero */ 246d35170d6Srm static int exec_exitcode = 0; 247b34cd89aSYuri Pankov static regex_t *preg = NULL; 248b34cd89aSYuri Pankov static int npreg = 0; 249b34cd89aSYuri Pankov static int mindepth = -1, maxdepth = -1; 2507c478bd9Sstevel@tonic-gate extern char **environ; 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate int 2537c478bd9Sstevel@tonic-gate main(int argc, char **argv) 2547c478bd9Sstevel@tonic-gate { 2557c478bd9Sstevel@tonic-gate char *cp; 2567c478bd9Sstevel@tonic-gate int c; 2577c478bd9Sstevel@tonic-gate int paths; 2587c478bd9Sstevel@tonic-gate char *cwdpath; 2597c478bd9Sstevel@tonic-gate 2607c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 2617c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 2627c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 2637c478bd9Sstevel@tonic-gate #endif 2647c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate cmdname = argv[0]; 2677c478bd9Sstevel@tonic-gate if (time(&now) == (time_t)(-1)) { 2687c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: time() %s\n"), 2693d63ea05Sas cmdname, strerror(errno)); 2707c478bd9Sstevel@tonic-gate exit(1); 2717c478bd9Sstevel@tonic-gate } 272b34cd89aSYuri Pankov while ((c = getopt(argc, argv, "EHL")) != -1) { 2737c478bd9Sstevel@tonic-gate switch (c) { 274b34cd89aSYuri Pankov case 'E': 275b34cd89aSYuri Pankov Eflag = 1; 276b34cd89aSYuri Pankov break; 2777c478bd9Sstevel@tonic-gate case 'H': 2787c478bd9Sstevel@tonic-gate hflag = 1; 2797c478bd9Sstevel@tonic-gate lflag = 0; 2807c478bd9Sstevel@tonic-gate break; 2817c478bd9Sstevel@tonic-gate case 'L': 2827c478bd9Sstevel@tonic-gate hflag = 0; 2837c478bd9Sstevel@tonic-gate lflag = 1; 2847c478bd9Sstevel@tonic-gate break; 2857c478bd9Sstevel@tonic-gate case '?': 2867c478bd9Sstevel@tonic-gate usage(); 2877c478bd9Sstevel@tonic-gate break; 2887c478bd9Sstevel@tonic-gate } 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate argc -= optind; 2927c478bd9Sstevel@tonic-gate argv += optind; 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate if (argc < 1) { 2957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 2967c478bd9Sstevel@tonic-gate gettext("%s: insufficient number of arguments\n"), cmdname); 2977c478bd9Sstevel@tonic-gate usage(); 2987c478bd9Sstevel@tonic-gate } 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate for (paths = 0; (cp = argv[paths]) != 0; ++paths) { 3017c478bd9Sstevel@tonic-gate if (*cp == '-') 3027c478bd9Sstevel@tonic-gate break; 3037c478bd9Sstevel@tonic-gate else if ((*cp == '!' || *cp == '(') && *(cp+1) == 0) 3047c478bd9Sstevel@tonic-gate break; 3057c478bd9Sstevel@tonic-gate } 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate if (paths == 0) /* no path-list */ 3087c478bd9Sstevel@tonic-gate usage(); 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate output = stdout; 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate /* lflag is the same as -follow */ 3137c478bd9Sstevel@tonic-gate if (lflag) 3147c478bd9Sstevel@tonic-gate walkflags &= ~FTW_PHYS; 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate /* allocate enough space for the compiler */ 3177c478bd9Sstevel@tonic-gate topnode = malloc((argc + 1) * sizeof (struct Node)); 3187c478bd9Sstevel@tonic-gate (void) memset(topnode, 0, (argc + 1) * sizeof (struct Node)); 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate if (compile(argv + paths, topnode, &action_expression) == 0) { 3217c478bd9Sstevel@tonic-gate /* no expression, default to -print */ 3227c478bd9Sstevel@tonic-gate (void) memcpy(topnode, &PRINT_NODE, sizeof (struct Node)); 3237c478bd9Sstevel@tonic-gate } else if (!action_expression) { 3247c478bd9Sstevel@tonic-gate /* 3257c478bd9Sstevel@tonic-gate * if no action expression, insert an LPAREN node above topnode, 3267c478bd9Sstevel@tonic-gate * with a PRINT node as its next node 3277c478bd9Sstevel@tonic-gate */ 3287c478bd9Sstevel@tonic-gate struct Node *savenode; 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate if (freenode == NULL) { 3317c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: can't append -print" 3323d63ea05Sas " implicitly; try explicit -print option\n"), 3333d63ea05Sas cmdname); 3347c478bd9Sstevel@tonic-gate exit(1); 3357c478bd9Sstevel@tonic-gate } 3367c478bd9Sstevel@tonic-gate savenode = topnode; 3377c478bd9Sstevel@tonic-gate topnode = freenode++; 3387c478bd9Sstevel@tonic-gate (void) memcpy(topnode, &LPAREN_NODE, sizeof (struct Node)); 3397c478bd9Sstevel@tonic-gate topnode->next = freenode; 3407c478bd9Sstevel@tonic-gate topnode->first.np = savenode; 3417c478bd9Sstevel@tonic-gate (void) memcpy(topnode->next, &PRINT_NODE, sizeof (struct Node)); 3427c478bd9Sstevel@tonic-gate } 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate while (paths--) { 3457c478bd9Sstevel@tonic-gate char *curpath; 3467c478bd9Sstevel@tonic-gate struct stat sb; 3477c478bd9Sstevel@tonic-gate 3487c478bd9Sstevel@tonic-gate curpath = *(argv++); 3497c478bd9Sstevel@tonic-gate 3507c478bd9Sstevel@tonic-gate /* 3517c478bd9Sstevel@tonic-gate * If -H is specified, it means we walk the first 3527c478bd9Sstevel@tonic-gate * level (pathname on command line) logically, following 3537c478bd9Sstevel@tonic-gate * symlinks, but lower levels are walked physically. 3547c478bd9Sstevel@tonic-gate * We use our own secret interface to nftw() to change 3557c478bd9Sstevel@tonic-gate * the from stat to lstat after the top level is walked. 3567c478bd9Sstevel@tonic-gate */ 3577c478bd9Sstevel@tonic-gate if (hflag) { 3587c478bd9Sstevel@tonic-gate if (stat(curpath, &sb) < 0 && errno == ENOENT) 3597c478bd9Sstevel@tonic-gate walkflags &= ~FTW_HOPTION; 3607c478bd9Sstevel@tonic-gate else 3617c478bd9Sstevel@tonic-gate walkflags |= FTW_HOPTION; 3627c478bd9Sstevel@tonic-gate } 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate /* 3657c478bd9Sstevel@tonic-gate * We need this check as nftw needs a CWD and we have no 3667c478bd9Sstevel@tonic-gate * way of returning back from that code with a meaningful 3677c478bd9Sstevel@tonic-gate * error related to this 3687c478bd9Sstevel@tonic-gate */ 3697c478bd9Sstevel@tonic-gate if ((cwdpath = getcwd(NULL, PATH_MAX)) == NULL) { 3704b808d43SRich Burridge if ((errno == EACCES) && (walkflags & FTW_CHDIR)) { 3714b808d43SRich Burridge /* 3724b808d43SRich Burridge * A directory above cwd is inaccessible, 3734b808d43SRich Burridge * so don't do chdir(2)s. Slower, but at least 3744b808d43SRich Burridge * it works. 3754b808d43SRich Burridge */ 3764b808d43SRich Burridge walkflags &= ~FTW_CHDIR; 3774b808d43SRich Burridge free(cwdpath); 3784b808d43SRich Burridge } else { 3794b808d43SRich Burridge (void) fprintf(stderr, 3804b808d43SRich Burridge gettext("%s : cannot get the current " 3814b808d43SRich Burridge "working directory\n"), cmdname); 3824b808d43SRich Burridge exit(1); 3834b808d43SRich Burridge } 3847c478bd9Sstevel@tonic-gate } else 3857c478bd9Sstevel@tonic-gate free(cwdpath); 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate if (nftw(curpath, execute, 1000, walkflags)) { 3897c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 3907c478bd9Sstevel@tonic-gate gettext("%s: cannot open %s: %s\n"), 3917c478bd9Sstevel@tonic-gate cmdname, curpath, strerror(errno)); 3927c478bd9Sstevel@tonic-gate error = 1; 3937c478bd9Sstevel@tonic-gate } 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate } 3967c478bd9Sstevel@tonic-gate 3977c478bd9Sstevel@tonic-gate /* execute any remaining variable length lists */ 3987c478bd9Sstevel@tonic-gate while (lastlist) { 3997c478bd9Sstevel@tonic-gate if (lastlist->end != lastlist->nextstr) { 4007c478bd9Sstevel@tonic-gate *lastlist->nextvar = 0; 401d35170d6Srm (void) doexec((char *)0, lastlist->arglist, 402d35170d6Srm &exec_exitcode); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate lastlist = lastlist->next; 4057c478bd9Sstevel@tonic-gate } 4067c478bd9Sstevel@tonic-gate if (output != stdout) 4077c478bd9Sstevel@tonic-gate return (cmdclose(output)); 408d35170d6Srm return ((exec_exitcode != 0) ? exec_exitcode : error); 4097c478bd9Sstevel@tonic-gate } 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate /* 4127c478bd9Sstevel@tonic-gate * compile the arguments 4137c478bd9Sstevel@tonic-gate */ 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate static int 4167c478bd9Sstevel@tonic-gate compile(argv, np, actionp) 4177c478bd9Sstevel@tonic-gate char **argv; 4187c478bd9Sstevel@tonic-gate struct Node *np; 4197c478bd9Sstevel@tonic-gate int *actionp; 4207c478bd9Sstevel@tonic-gate { 4217c478bd9Sstevel@tonic-gate char *b; 4227c478bd9Sstevel@tonic-gate char **av; 4237c478bd9Sstevel@tonic-gate struct Node *oldnp = topnode; 4247c478bd9Sstevel@tonic-gate struct Args *argp; 4257c478bd9Sstevel@tonic-gate char **com; 4267c478bd9Sstevel@tonic-gate int i; 4277c478bd9Sstevel@tonic-gate enum Command wasop = PRINT; 4287c478bd9Sstevel@tonic-gate 4293d63ea05Sas if (init_yes() < 0) { 4303d63ea05Sas (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES), 4313d63ea05Sas strerror(errno)); 4323d63ea05Sas exit(1); 4333d63ea05Sas } 4343d63ea05Sas 4357c478bd9Sstevel@tonic-gate for (av = argv; *av && (argp = lookup(*av)); av++) { 4367c478bd9Sstevel@tonic-gate np->next = 0; 4377c478bd9Sstevel@tonic-gate np->action = argp->action; 4387c478bd9Sstevel@tonic-gate np->type = argp->type; 4397c478bd9Sstevel@tonic-gate np->second.i = 0; 4407c478bd9Sstevel@tonic-gate if (argp->type == Op) { 4417c478bd9Sstevel@tonic-gate if (wasop == NOT || (wasop && np->action != NOT)) { 4427c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4437c478bd9Sstevel@tonic-gate gettext("%s: operand follows operand\n"), 4447c478bd9Sstevel@tonic-gate cmdname); 4457c478bd9Sstevel@tonic-gate exit(1); 4467c478bd9Sstevel@tonic-gate } 4477c478bd9Sstevel@tonic-gate if (np->action != NOT && oldnp == 0) 4487c478bd9Sstevel@tonic-gate goto err; 4497c478bd9Sstevel@tonic-gate wasop = argp->action; 4507c478bd9Sstevel@tonic-gate } else { 4517c478bd9Sstevel@tonic-gate wasop = PRINT; 4527c478bd9Sstevel@tonic-gate if (argp->type != Unary) { 4537c478bd9Sstevel@tonic-gate if (!(b = *++av)) { 4547c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4557c478bd9Sstevel@tonic-gate gettext("%s: incomplete statement\n"), 4567c478bd9Sstevel@tonic-gate cmdname); 4577c478bd9Sstevel@tonic-gate exit(1); 4587c478bd9Sstevel@tonic-gate } 4597c478bd9Sstevel@tonic-gate if (argp->type == Num) { 460b34cd89aSYuri Pankov if (((argp->action == MAXDEPTH) || 461b34cd89aSYuri Pankov (argp->action == MINDEPTH)) && 462b34cd89aSYuri Pankov ((int)strtol(b, (char **)NULL, 463b34cd89aSYuri Pankov 10) < 0)) 464b34cd89aSYuri Pankov errx(1, 465b34cd89aSYuri Pankov gettext("%s: value must be positive"), 466b34cd89aSYuri Pankov (argp->action == MAXDEPTH) ? 467b34cd89aSYuri Pankov "maxdepth" : "mindepth"); 4687c478bd9Sstevel@tonic-gate if ((argp->action != PERM) || 4697c478bd9Sstevel@tonic-gate (*b != '+')) { 4707c478bd9Sstevel@tonic-gate if (*b == '+' || *b == '-') { 4717c478bd9Sstevel@tonic-gate np->second.i = *b; 4727c478bd9Sstevel@tonic-gate b++; 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate } 4757c478bd9Sstevel@tonic-gate } 4767c478bd9Sstevel@tonic-gate } 4777c478bd9Sstevel@tonic-gate } 4787c478bd9Sstevel@tonic-gate switch (argp->action) { 4797c478bd9Sstevel@tonic-gate case AND: 4807c478bd9Sstevel@tonic-gate break; 4817c478bd9Sstevel@tonic-gate case NOT: 4827c478bd9Sstevel@tonic-gate break; 4837c478bd9Sstevel@tonic-gate case OR: 4847c478bd9Sstevel@tonic-gate np->first.np = topnode; 4857c478bd9Sstevel@tonic-gate topnode = np; 4867c478bd9Sstevel@tonic-gate oldnp->next = 0; 4877c478bd9Sstevel@tonic-gate break; 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate case LPAREN: { 4907c478bd9Sstevel@tonic-gate struct Node *save = topnode; 4917c478bd9Sstevel@tonic-gate topnode = np+1; 4927c478bd9Sstevel@tonic-gate paren_cnt++; 4937c478bd9Sstevel@tonic-gate i = compile(++av, topnode, actionp); 4947c478bd9Sstevel@tonic-gate np->first.np = topnode; 4957c478bd9Sstevel@tonic-gate topnode = save; 4967c478bd9Sstevel@tonic-gate av += i; 4977c478bd9Sstevel@tonic-gate oldnp = np; 4987c478bd9Sstevel@tonic-gate np += i + 1; 4997c478bd9Sstevel@tonic-gate oldnp->next = np; 5007c478bd9Sstevel@tonic-gate continue; 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate case RPAREN: 5047c478bd9Sstevel@tonic-gate if (paren_cnt <= 0) { 5057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5067c478bd9Sstevel@tonic-gate gettext("%s: unmatched ')'\n"), 5077c478bd9Sstevel@tonic-gate cmdname); 5087c478bd9Sstevel@tonic-gate exit(1); 5097c478bd9Sstevel@tonic-gate } 5107c478bd9Sstevel@tonic-gate paren_cnt--; 5117c478bd9Sstevel@tonic-gate if (oldnp == 0) 5127c478bd9Sstevel@tonic-gate goto err; 5137c478bd9Sstevel@tonic-gate if (oldnp->type == Op) { 5147c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5157c478bd9Sstevel@tonic-gate gettext("%s: cannot immediately" 5167c478bd9Sstevel@tonic-gate " follow an operand with ')'\n"), 5177c478bd9Sstevel@tonic-gate cmdname); 5187c478bd9Sstevel@tonic-gate exit(1); 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate oldnp->next = 0; 5217c478bd9Sstevel@tonic-gate return (av-argv); 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate case FOLLOW: 5247c478bd9Sstevel@tonic-gate walkflags &= ~FTW_PHYS; 5257c478bd9Sstevel@tonic-gate break; 5267c478bd9Sstevel@tonic-gate case MOUNT: 5277c478bd9Sstevel@tonic-gate walkflags |= FTW_MOUNT; 5287c478bd9Sstevel@tonic-gate break; 5297c478bd9Sstevel@tonic-gate case DEPTH: 5307c478bd9Sstevel@tonic-gate walkflags |= FTW_DEPTH; 5317c478bd9Sstevel@tonic-gate break; 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate case LOCAL: 5347c478bd9Sstevel@tonic-gate np->first.l = 0L; 5357c478bd9Sstevel@tonic-gate np->first.ll = 0LL; 5367c478bd9Sstevel@tonic-gate np->second.i = '+'; 5377c478bd9Sstevel@tonic-gate /* 5387c478bd9Sstevel@tonic-gate * Make it compatible to df -l for 5397c478bd9Sstevel@tonic-gate * future enhancement. So, anything 5407c478bd9Sstevel@tonic-gate * that is not remote, then it is 5417c478bd9Sstevel@tonic-gate * local. 5427c478bd9Sstevel@tonic-gate */ 5437c478bd9Sstevel@tonic-gate init_remote_fs(); 5447c478bd9Sstevel@tonic-gate break; 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate case SIZE: 5477c478bd9Sstevel@tonic-gate if (b[strlen(b)-1] == 'c') 5487c478bd9Sstevel@tonic-gate np->action = CSIZE; 5497c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 5507c478bd9Sstevel@tonic-gate case INUM: 5517c478bd9Sstevel@tonic-gate np->first.ll = atoll(b); 5527c478bd9Sstevel@tonic-gate break; 5537c478bd9Sstevel@tonic-gate 554da1a9cbeSjonb case CMIN: 5557c478bd9Sstevel@tonic-gate case CTIME: 556da1a9cbeSjonb case MMIN: 5577c478bd9Sstevel@tonic-gate case MTIME: 558da1a9cbeSjonb case AMIN: 5597c478bd9Sstevel@tonic-gate case ATIME: 5607c478bd9Sstevel@tonic-gate case LINKS: 5617c478bd9Sstevel@tonic-gate np->first.l = atol(b); 5627c478bd9Sstevel@tonic-gate break; 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate case F_USER: 565b34cd89aSYuri Pankov case F_GROUP: 566b34cd89aSYuri Pankov case F_USERACL: 567b34cd89aSYuri Pankov case F_GROUPACL: { 5687c478bd9Sstevel@tonic-gate struct passwd *pw; 5697c478bd9Sstevel@tonic-gate struct group *gr; 570ef497ae3SRich Burridge long value; 571ef497ae3SRich Burridge char *q; 572ef497ae3SRich Burridge 573ef497ae3SRich Burridge value = -1; 574b34cd89aSYuri Pankov if (argp->action == F_USER || 575b34cd89aSYuri Pankov argp->action == F_USERACL) { 5767c478bd9Sstevel@tonic-gate if ((pw = getpwnam(b)) != 0) 577ef497ae3SRich Burridge value = (long)pw->pw_uid; 5787c478bd9Sstevel@tonic-gate } else { 5797c478bd9Sstevel@tonic-gate if ((gr = getgrnam(b)) != 0) 580ef497ae3SRich Burridge value = (long)gr->gr_gid; 5817c478bd9Sstevel@tonic-gate } 582ef497ae3SRich Burridge if (value == -1) { 583ef497ae3SRich Burridge errno = 0; 584ef497ae3SRich Burridge value = strtol(b, &q, 10); 585ef497ae3SRich Burridge if (errno != 0 || q == b || *q != '\0') { 5867c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 5877c478bd9Sstevel@tonic-gate "%s: cannot find %s name\n"), 5887c478bd9Sstevel@tonic-gate cmdname, *av); 5897c478bd9Sstevel@tonic-gate exit(1); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate } 592ef497ae3SRich Burridge np->first.l = value; 5937c478bd9Sstevel@tonic-gate break; 5947c478bd9Sstevel@tonic-gate } 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate case EXEC: 5977c478bd9Sstevel@tonic-gate case OK: 5987c478bd9Sstevel@tonic-gate walkflags &= ~FTW_CHDIR; 5997c478bd9Sstevel@tonic-gate np->first.ap = av; 6007c478bd9Sstevel@tonic-gate (*actionp)++; 6017c478bd9Sstevel@tonic-gate for (;;) { 6027c478bd9Sstevel@tonic-gate if ((b = *av) == 0) { 6037c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6047c478bd9Sstevel@tonic-gate gettext("%s: incomplete statement\n"), 6057c478bd9Sstevel@tonic-gate cmdname); 6067c478bd9Sstevel@tonic-gate exit(1); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate if (strcmp(b, ";") == 0) { 6097c478bd9Sstevel@tonic-gate *av = 0; 6107c478bd9Sstevel@tonic-gate break; 6117c478bd9Sstevel@tonic-gate } else if (strcmp(b, "{}") == 0) 6127c478bd9Sstevel@tonic-gate *av = dummyarg; 6137c478bd9Sstevel@tonic-gate else if (strcmp(b, "+") == 0 && 6147c478bd9Sstevel@tonic-gate av[-1] == dummyarg && 6157c478bd9Sstevel@tonic-gate np->action == EXEC) { 6167c478bd9Sstevel@tonic-gate av[-1] = 0; 6177c478bd9Sstevel@tonic-gate np->first.vp = varargs(np->first.ap); 6187c478bd9Sstevel@tonic-gate np->action = VARARGS; 6197c478bd9Sstevel@tonic-gate break; 6207c478bd9Sstevel@tonic-gate } 6217c478bd9Sstevel@tonic-gate av++; 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate break; 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate case NAME: 626b34cd89aSYuri Pankov case INAME: 627*05f32410SAndy Stormont case PATH: 628*05f32410SAndy Stormont case IPATH: 6297c478bd9Sstevel@tonic-gate np->first.cp = b; 6307c478bd9Sstevel@tonic-gate break; 631b34cd89aSYuri Pankov case REGEX: 632b34cd89aSYuri Pankov case IREGEX: { 633b34cd89aSYuri Pankov int error; 634b34cd89aSYuri Pankov size_t errlen; 635b34cd89aSYuri Pankov char *errmsg; 636b34cd89aSYuri Pankov 637b34cd89aSYuri Pankov if ((preg = realloc(preg, (npreg + 1) * 638b34cd89aSYuri Pankov sizeof (regex_t))) == NULL) 639b34cd89aSYuri Pankov err(1, "realloc"); 640b34cd89aSYuri Pankov if ((error = regcomp(&preg[npreg], b, 641b34cd89aSYuri Pankov ((np->action == IREGEX) ? REG_ICASE : 0) | 642b34cd89aSYuri Pankov ((Eflag) ? REG_EXTENDED : 0))) != 0) { 643b34cd89aSYuri Pankov errlen = regerror(error, &preg[npreg], NULL, 0); 644b34cd89aSYuri Pankov if ((errmsg = malloc(errlen)) == NULL) 645b34cd89aSYuri Pankov err(1, "malloc"); 646b34cd89aSYuri Pankov (void) regerror(error, &preg[npreg], errmsg, 647b34cd89aSYuri Pankov errlen); 648b34cd89aSYuri Pankov errx(1, gettext("RE error: %s"), errmsg); 649b34cd89aSYuri Pankov } 650b34cd89aSYuri Pankov npreg++; 651b34cd89aSYuri Pankov break; 652b34cd89aSYuri Pankov } 6537c478bd9Sstevel@tonic-gate case PERM: 6547c478bd9Sstevel@tonic-gate if (*b == '-') 6557c478bd9Sstevel@tonic-gate ++b; 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate if (readmode(b) != NULL) { 6587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 6597c478bd9Sstevel@tonic-gate "find: -perm: Bad permission string\n")); 6607c478bd9Sstevel@tonic-gate usage(); 6617c478bd9Sstevel@tonic-gate } 6627c478bd9Sstevel@tonic-gate np->first.l = (long)getmode((mode_t)0); 6637c478bd9Sstevel@tonic-gate break; 6647c478bd9Sstevel@tonic-gate case TYPE: 6657c478bd9Sstevel@tonic-gate i = *b; 6667c478bd9Sstevel@tonic-gate np->first.l = 6677c478bd9Sstevel@tonic-gate i == 'd' ? S_IFDIR : 6687c478bd9Sstevel@tonic-gate i == 'b' ? S_IFBLK : 6697c478bd9Sstevel@tonic-gate i == 'c' ? S_IFCHR : 6707c478bd9Sstevel@tonic-gate #ifdef S_IFIFO 6717c478bd9Sstevel@tonic-gate i == 'p' ? S_IFIFO : 6727c478bd9Sstevel@tonic-gate #endif 6737c478bd9Sstevel@tonic-gate i == 'f' ? S_IFREG : 6747c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 6757c478bd9Sstevel@tonic-gate i == 'l' ? S_IFLNK : 6767c478bd9Sstevel@tonic-gate #endif 6777c478bd9Sstevel@tonic-gate #ifdef S_IFSOCK 6787c478bd9Sstevel@tonic-gate i == 's' ? S_IFSOCK : 6797c478bd9Sstevel@tonic-gate #endif 6807c478bd9Sstevel@tonic-gate #ifdef S_IFDOOR 6817c478bd9Sstevel@tonic-gate i == 'D' ? S_IFDOOR : 6827c478bd9Sstevel@tonic-gate #endif 6837c478bd9Sstevel@tonic-gate 0; 6847c478bd9Sstevel@tonic-gate break; 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate case CPIO: 6877c478bd9Sstevel@tonic-gate if (walkflags & FTW_PHYS) 6887c478bd9Sstevel@tonic-gate com = cpio; 6897c478bd9Sstevel@tonic-gate else 6907c478bd9Sstevel@tonic-gate com = cpiol; 6917c478bd9Sstevel@tonic-gate goto common; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate case NCPIO: { 6947c478bd9Sstevel@tonic-gate FILE *fd; 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate if (walkflags & FTW_PHYS) 6977c478bd9Sstevel@tonic-gate com = ncpio; 6987c478bd9Sstevel@tonic-gate else 6997c478bd9Sstevel@tonic-gate com = ncpiol; 7007c478bd9Sstevel@tonic-gate common: 7017c478bd9Sstevel@tonic-gate /* set up cpio */ 7027c478bd9Sstevel@tonic-gate if ((fd = fopen(b, "w")) == NULL) { 7037c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7047c478bd9Sstevel@tonic-gate gettext("%s: cannot create %s\n"), 7057c478bd9Sstevel@tonic-gate cmdname, b); 7067c478bd9Sstevel@tonic-gate exit(1); 7077c478bd9Sstevel@tonic-gate } 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate np->first.l = (long)cmdopen("cpio", com, "w", fd); 7107c478bd9Sstevel@tonic-gate (void) fclose(fd); 7117c478bd9Sstevel@tonic-gate walkflags |= FTW_DEPTH; 7127c478bd9Sstevel@tonic-gate np->action = CPIO; 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 7157c478bd9Sstevel@tonic-gate case PRINT: 716b34cd89aSYuri Pankov case PRINT0: 7177c478bd9Sstevel@tonic-gate (*actionp)++; 7187c478bd9Sstevel@tonic-gate break; 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate case NEWER: { 7217c478bd9Sstevel@tonic-gate struct stat statb; 7227c478bd9Sstevel@tonic-gate if (stat(b, &statb) < 0) { 7237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7247c478bd9Sstevel@tonic-gate gettext("%s: cannot access %s\n"), 7257c478bd9Sstevel@tonic-gate cmdname, b); 7267c478bd9Sstevel@tonic-gate exit(1); 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate np->first.l = statb.st_mtime; 7297c478bd9Sstevel@tonic-gate np->second.i = '+'; 7307c478bd9Sstevel@tonic-gate break; 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate case PRUNE: 7347c478bd9Sstevel@tonic-gate case NOUSER: 7357c478bd9Sstevel@tonic-gate case NOGRP: 7367c478bd9Sstevel@tonic-gate break; 7377c478bd9Sstevel@tonic-gate case FSTYPE: 7387c478bd9Sstevel@tonic-gate np->first.cp = b; 7397c478bd9Sstevel@tonic-gate break; 7407c478bd9Sstevel@tonic-gate case LS: 7417c478bd9Sstevel@tonic-gate (*actionp)++; 7427c478bd9Sstevel@tonic-gate break; 7437c478bd9Sstevel@tonic-gate case XATTR: 7447c478bd9Sstevel@tonic-gate break; 7457c478bd9Sstevel@tonic-gate case ACL: 7467c478bd9Sstevel@tonic-gate break; 747b34cd89aSYuri Pankov case MAXDEPTH: 748b34cd89aSYuri Pankov maxdepth = (int)strtol(b, (char **)NULL, 10); 749b34cd89aSYuri Pankov break; 750b34cd89aSYuri Pankov case MINDEPTH: 751b34cd89aSYuri Pankov mindepth = (int)strtol(b, (char **)NULL, 10); 752b34cd89aSYuri Pankov break; 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate oldnp = np++; 7567c478bd9Sstevel@tonic-gate oldnp->next = np; 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate if ((*av) || (wasop)) 7607c478bd9Sstevel@tonic-gate goto err; 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate if (paren_cnt != 0) { 7637c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: unmatched '('\n"), 7647c478bd9Sstevel@tonic-gate cmdname); 7657c478bd9Sstevel@tonic-gate exit(1); 7667c478bd9Sstevel@tonic-gate } 7677c478bd9Sstevel@tonic-gate 7687c478bd9Sstevel@tonic-gate /* just before returning, save next free node from the list */ 7697c478bd9Sstevel@tonic-gate freenode = oldnp->next; 7707c478bd9Sstevel@tonic-gate oldnp->next = 0; 7717c478bd9Sstevel@tonic-gate return (av-argv); 7727c478bd9Sstevel@tonic-gate err: 7737c478bd9Sstevel@tonic-gate if (*av) 7747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7757c478bd9Sstevel@tonic-gate gettext("%s: bad option %s\n"), cmdname, *av); 7767c478bd9Sstevel@tonic-gate else 7777c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: bad option\n"), cmdname); 7787c478bd9Sstevel@tonic-gate usage(); 7797c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate /* 7837c478bd9Sstevel@tonic-gate * print out a usage message 7847c478bd9Sstevel@tonic-gate */ 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate static void 7876c83d09fSrobbin usage(void) 7887c478bd9Sstevel@tonic-gate { 7897c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 790b34cd89aSYuri Pankov gettext("%s: [-E] [-H | -L] path-list predicate-list\n"), cmdname); 7917c478bd9Sstevel@tonic-gate exit(1); 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate /* 7957c478bd9Sstevel@tonic-gate * This is the function that gets executed at each node 7967c478bd9Sstevel@tonic-gate */ 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate static int 7997c478bd9Sstevel@tonic-gate execute(name, statb, type, state) 8007c478bd9Sstevel@tonic-gate char *name; 8017c478bd9Sstevel@tonic-gate struct stat *statb; 8027c478bd9Sstevel@tonic-gate int type; 8037c478bd9Sstevel@tonic-gate struct FTW *state; 8047c478bd9Sstevel@tonic-gate { 8057c478bd9Sstevel@tonic-gate struct Node *np = topnode; 8067c478bd9Sstevel@tonic-gate int val; 8077c478bd9Sstevel@tonic-gate time_t t; 8087c478bd9Sstevel@tonic-gate long l; 8097c478bd9Sstevel@tonic-gate long long ll; 8107c478bd9Sstevel@tonic-gate int not = 1; 8117c478bd9Sstevel@tonic-gate char *filename; 812b34cd89aSYuri Pankov int cnpreg = 0; 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate if (type == FTW_NS) { 8157c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: stat() error %s: %s\n"), 8167c478bd9Sstevel@tonic-gate cmdname, name, strerror(errno)); 8177c478bd9Sstevel@tonic-gate error = 1; 8187c478bd9Sstevel@tonic-gate return (0); 8197c478bd9Sstevel@tonic-gate } else if (type == FTW_DNR) { 8207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: cannot read dir %s: %s\n"), 8217c478bd9Sstevel@tonic-gate cmdname, name, strerror(errno)); 8227c478bd9Sstevel@tonic-gate error = 1; 8230729abfeSRich Burridge } else if (type == FTW_SLN && lflag == 1) { 8247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 8257c478bd9Sstevel@tonic-gate gettext("%s: cannot follow symbolic link %s: %s\n"), 8267c478bd9Sstevel@tonic-gate cmdname, name, strerror(errno)); 8277c478bd9Sstevel@tonic-gate error = 1; 82868a94df1Scf } else if (type == FTW_DL) { 82968a94df1Scf (void) fprintf(stderr, gettext("%s: cycle detected for %s\n"), 83068a94df1Scf cmdname, name); 83168a94df1Scf error = 1; 83268a94df1Scf return (0); 8337c478bd9Sstevel@tonic-gate } 8347c478bd9Sstevel@tonic-gate 835b34cd89aSYuri Pankov if ((maxdepth != -1 && state->level > maxdepth) || 836b34cd89aSYuri Pankov (mindepth != -1 && state->level < mindepth)) 837b34cd89aSYuri Pankov return (0); 838b34cd89aSYuri Pankov 8397c478bd9Sstevel@tonic-gate while (np) { 8407c478bd9Sstevel@tonic-gate switch (np->action) { 8417c478bd9Sstevel@tonic-gate case NOT: 8427c478bd9Sstevel@tonic-gate not = !not; 8437c478bd9Sstevel@tonic-gate np = np->next; 8447c478bd9Sstevel@tonic-gate continue; 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate case AND: 8477c478bd9Sstevel@tonic-gate np = np->next; 8487c478bd9Sstevel@tonic-gate continue; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate case OR: 8517c478bd9Sstevel@tonic-gate if (np->first.np == np) { 8527c478bd9Sstevel@tonic-gate /* 8537c478bd9Sstevel@tonic-gate * handle naked OR (no term on left hand side) 8547c478bd9Sstevel@tonic-gate */ 8557c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 8567c478bd9Sstevel@tonic-gate gettext("%s: invalid -o construction\n"), 8577c478bd9Sstevel@tonic-gate cmdname); 8587c478bd9Sstevel@tonic-gate exit(2); 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 8617c478bd9Sstevel@tonic-gate case LPAREN: { 8627c478bd9Sstevel@tonic-gate struct Node *save = topnode; 8637c478bd9Sstevel@tonic-gate topnode = np->first.np; 8647c478bd9Sstevel@tonic-gate (void) execute(name, statb, type, state); 8657c478bd9Sstevel@tonic-gate val = lastval; 8667c478bd9Sstevel@tonic-gate topnode = save; 8677c478bd9Sstevel@tonic-gate if (np->action == OR) { 8687c478bd9Sstevel@tonic-gate if (val) 8697c478bd9Sstevel@tonic-gate return (0); 8707c478bd9Sstevel@tonic-gate val = 1; 8717c478bd9Sstevel@tonic-gate } 8727c478bd9Sstevel@tonic-gate break; 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate case LOCAL: { 8767c478bd9Sstevel@tonic-gate int nremfs; 8777c478bd9Sstevel@tonic-gate val = 1; 8787c478bd9Sstevel@tonic-gate /* 8797c478bd9Sstevel@tonic-gate * If file system type matches the remote 8807c478bd9Sstevel@tonic-gate * file system type, then it is not local. 8817c478bd9Sstevel@tonic-gate */ 8827c478bd9Sstevel@tonic-gate for (nremfs = 0; nremfs < fstype_index; nremfs++) { 8837c478bd9Sstevel@tonic-gate if (strcmp(remote_fstypes[nremfs], 8847c478bd9Sstevel@tonic-gate statb->st_fstype) == 0) { 8857c478bd9Sstevel@tonic-gate val = 0; 8867c478bd9Sstevel@tonic-gate break; 8877c478bd9Sstevel@tonic-gate } 8887c478bd9Sstevel@tonic-gate } 8897c478bd9Sstevel@tonic-gate break; 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate case TYPE: 8937c478bd9Sstevel@tonic-gate l = (long)statb->st_mode&S_IFMT; 8947c478bd9Sstevel@tonic-gate goto num; 8957c478bd9Sstevel@tonic-gate 8967c478bd9Sstevel@tonic-gate case PERM: 8977c478bd9Sstevel@tonic-gate l = (long)statb->st_mode&07777; 8987c478bd9Sstevel@tonic-gate if (np->second.i == '-') 8997c478bd9Sstevel@tonic-gate val = ((l&np->first.l) == np->first.l); 9007c478bd9Sstevel@tonic-gate else 9017c478bd9Sstevel@tonic-gate val = (l == np->first.l); 9027c478bd9Sstevel@tonic-gate break; 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate case INUM: 9057c478bd9Sstevel@tonic-gate ll = (long long)statb->st_ino; 9067c478bd9Sstevel@tonic-gate goto llnum; 9077c478bd9Sstevel@tonic-gate case NEWER: 9087c478bd9Sstevel@tonic-gate l = statb->st_mtime; 9097c478bd9Sstevel@tonic-gate goto num; 9107c478bd9Sstevel@tonic-gate case ATIME: 9117c478bd9Sstevel@tonic-gate t = statb->st_atime; 9127c478bd9Sstevel@tonic-gate goto days; 9137c478bd9Sstevel@tonic-gate case CTIME: 9147c478bd9Sstevel@tonic-gate t = statb->st_ctime; 9157c478bd9Sstevel@tonic-gate goto days; 9167c478bd9Sstevel@tonic-gate case MTIME: 9177c478bd9Sstevel@tonic-gate t = statb->st_mtime; 9187c478bd9Sstevel@tonic-gate days: 9197c478bd9Sstevel@tonic-gate l = (now-t)/A_DAY; 9207c478bd9Sstevel@tonic-gate goto num; 921da1a9cbeSjonb case MMIN: 922da1a9cbeSjonb t = statb->st_mtime; 923da1a9cbeSjonb goto mins; 924da1a9cbeSjonb case AMIN: 925da1a9cbeSjonb t = statb->st_atime; 926da1a9cbeSjonb goto mins; 927da1a9cbeSjonb case CMIN: 928da1a9cbeSjonb t = statb->st_ctime; 929da1a9cbeSjonb goto mins; 930da1a9cbeSjonb mins: 931da1a9cbeSjonb l = (now-t)/A_MIN; 932da1a9cbeSjonb goto num; 9337c478bd9Sstevel@tonic-gate case CSIZE: 9347c478bd9Sstevel@tonic-gate ll = (long long)statb->st_size; 9357c478bd9Sstevel@tonic-gate goto llnum; 9367c478bd9Sstevel@tonic-gate case SIZE: 9377c478bd9Sstevel@tonic-gate ll = (long long)round(statb->st_size, BLKSIZ)/BLKSIZ; 9387c478bd9Sstevel@tonic-gate goto llnum; 9397c478bd9Sstevel@tonic-gate case F_USER: 9407c478bd9Sstevel@tonic-gate l = (long)statb->st_uid; 9417c478bd9Sstevel@tonic-gate goto num; 9427c478bd9Sstevel@tonic-gate case F_GROUP: 9437c478bd9Sstevel@tonic-gate l = (long)statb->st_gid; 9447c478bd9Sstevel@tonic-gate goto num; 9457c478bd9Sstevel@tonic-gate case LINKS: 9467c478bd9Sstevel@tonic-gate l = (long)statb->st_nlink; 9477c478bd9Sstevel@tonic-gate goto num; 9487c478bd9Sstevel@tonic-gate llnum: 9497c478bd9Sstevel@tonic-gate if (np->second.i == '+') 9507c478bd9Sstevel@tonic-gate val = (ll > np->first.ll); 9517c478bd9Sstevel@tonic-gate else if (np->second.i == '-') 9527c478bd9Sstevel@tonic-gate val = (ll < np->first.ll); 9537c478bd9Sstevel@tonic-gate else 9547c478bd9Sstevel@tonic-gate val = (ll == np->first.ll); 9557c478bd9Sstevel@tonic-gate break; 9567c478bd9Sstevel@tonic-gate num: 9577c478bd9Sstevel@tonic-gate if (np->second.i == '+') 9587c478bd9Sstevel@tonic-gate val = (l > np->first.l); 9597c478bd9Sstevel@tonic-gate else if (np->second.i == '-') 9607c478bd9Sstevel@tonic-gate val = (l < np->first.l); 9617c478bd9Sstevel@tonic-gate else 9627c478bd9Sstevel@tonic-gate val = (l == np->first.l); 9637c478bd9Sstevel@tonic-gate break; 9647c478bd9Sstevel@tonic-gate case OK: 9657c478bd9Sstevel@tonic-gate val = ok(name, np->first.ap); 9667c478bd9Sstevel@tonic-gate break; 9677c478bd9Sstevel@tonic-gate case EXEC: 968d35170d6Srm val = doexec(name, np->first.ap, NULL); 9697c478bd9Sstevel@tonic-gate break; 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate case VARARGS: { 9727c478bd9Sstevel@tonic-gate struct Arglist *ap = np->first.vp; 9737c478bd9Sstevel@tonic-gate char *cp; 9747c478bd9Sstevel@tonic-gate cp = ap->nextstr - (strlen(name)+1); 9757c478bd9Sstevel@tonic-gate if (cp >= (char *)(ap->nextvar+3)) { 9767c478bd9Sstevel@tonic-gate /* there is room just copy the name */ 9777c478bd9Sstevel@tonic-gate val = 1; 9787c478bd9Sstevel@tonic-gate (void) strcpy(cp, name); 9797c478bd9Sstevel@tonic-gate *ap->nextvar++ = cp; 9807c478bd9Sstevel@tonic-gate ap->nextstr = cp; 9817c478bd9Sstevel@tonic-gate } else { 9827c478bd9Sstevel@tonic-gate /* no more room, exec command */ 9837c478bd9Sstevel@tonic-gate *ap->nextvar++ = name; 9847c478bd9Sstevel@tonic-gate *ap->nextvar = 0; 9857c478bd9Sstevel@tonic-gate val = 1; 986d35170d6Srm (void) doexec((char *)0, ap->arglist, 987d35170d6Srm &exec_exitcode); 9887c478bd9Sstevel@tonic-gate ap->nextstr = ap->end; 9897c478bd9Sstevel@tonic-gate ap->nextvar = ap->firstvar; 9907c478bd9Sstevel@tonic-gate } 9917c478bd9Sstevel@tonic-gate break; 9927c478bd9Sstevel@tonic-gate } 9937c478bd9Sstevel@tonic-gate 9947c478bd9Sstevel@tonic-gate case DEPTH: 9957c478bd9Sstevel@tonic-gate case MOUNT: 9967c478bd9Sstevel@tonic-gate case FOLLOW: 9977c478bd9Sstevel@tonic-gate val = 1; 9987c478bd9Sstevel@tonic-gate break; 9997c478bd9Sstevel@tonic-gate 1000b34cd89aSYuri Pankov case NAME: 1001*05f32410SAndy Stormont case INAME: 1002*05f32410SAndy Stormont case PATH: 1003*05f32410SAndy Stormont case IPATH: { 1004*05f32410SAndy Stormont char *path; 1005*05f32410SAndy Stormont int fnmflags = 0; 1006*05f32410SAndy Stormont 1007*05f32410SAndy Stormont if (np->action == INAME || np->action == IPATH) 1008*05f32410SAndy Stormont fnmflags = FNM_IGNORECASE; 10099ab6dc39Schin 10109ab6dc39Schin /* 10119ab6dc39Schin * basename(3c) may modify name, so 10129ab6dc39Schin * we need to pass another string 10139ab6dc39Schin */ 1014*05f32410SAndy Stormont if ((path = strdup(name)) == NULL) { 10159ab6dc39Schin (void) fprintf(stderr, 10169ab6dc39Schin gettext("%s: cannot strdup() %s: %s\n"), 10176b238a5aSchin cmdname, name, strerror(errno)); 10189ab6dc39Schin exit(2); 10199ab6dc39Schin } 10207c478bd9Sstevel@tonic-gate /* 10217c478bd9Sstevel@tonic-gate * XPG4 find should not treat a leading '.' in a 10227c478bd9Sstevel@tonic-gate * filename specially for pattern matching. 10237c478bd9Sstevel@tonic-gate * /usr/bin/find will not pattern match a leading 10247c478bd9Sstevel@tonic-gate * '.' in a filename, unless '.' is explicitly 10257c478bd9Sstevel@tonic-gate * specified. 10267c478bd9Sstevel@tonic-gate */ 1027b34cd89aSYuri Pankov #ifndef XPG4 1028b34cd89aSYuri Pankov fnmflags |= FNM_PERIOD; 10297c478bd9Sstevel@tonic-gate #endif 1030*05f32410SAndy Stormont 1031*05f32410SAndy Stormont val = !fnmatch(np->first.cp, 1032*05f32410SAndy Stormont (np->action == NAME || np->action == INAME) 1033*05f32410SAndy Stormont ? basename(path) : path, fnmflags); 1034*05f32410SAndy Stormont free(path); 10357c478bd9Sstevel@tonic-gate break; 10367c478bd9Sstevel@tonic-gate } 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate case PRUNE: 10397c478bd9Sstevel@tonic-gate if (type == FTW_D) 10407c478bd9Sstevel@tonic-gate state->quit = FTW_PRUNE; 10417c478bd9Sstevel@tonic-gate val = 1; 10427c478bd9Sstevel@tonic-gate break; 10437c478bd9Sstevel@tonic-gate case NOUSER: 10447c478bd9Sstevel@tonic-gate val = ((getpwuid(statb->st_uid)) == 0); 10457c478bd9Sstevel@tonic-gate break; 10467c478bd9Sstevel@tonic-gate case NOGRP: 10477c478bd9Sstevel@tonic-gate val = ((getgrgid(statb->st_gid)) == 0); 10487c478bd9Sstevel@tonic-gate break; 10497c478bd9Sstevel@tonic-gate case FSTYPE: 10507c478bd9Sstevel@tonic-gate val = (strcmp(np->first.cp, statb->st_fstype) == 0); 10517c478bd9Sstevel@tonic-gate break; 10527c478bd9Sstevel@tonic-gate case CPIO: 10537c478bd9Sstevel@tonic-gate output = (FILE *)np->first.l; 10547c478bd9Sstevel@tonic-gate (void) fprintf(output, "%s\n", name); 10557c478bd9Sstevel@tonic-gate val = 1; 10567c478bd9Sstevel@tonic-gate break; 10577c478bd9Sstevel@tonic-gate case PRINT: 1058b34cd89aSYuri Pankov case PRINT0: 1059b34cd89aSYuri Pankov (void) fprintf(stdout, "%s%c", name, 1060b34cd89aSYuri Pankov (np->action == PRINT) ? '\n' : '\0'); 10617c478bd9Sstevel@tonic-gate val = 1; 10627c478bd9Sstevel@tonic-gate break; 10637c478bd9Sstevel@tonic-gate case LS: 10647c478bd9Sstevel@tonic-gate (void) list(name, statb); 10657c478bd9Sstevel@tonic-gate val = 1; 10667c478bd9Sstevel@tonic-gate break; 10677c478bd9Sstevel@tonic-gate case XATTR: 1068f467e6fbSJohn Sonnenschein filename = (walkflags & FTW_CHDIR) ? 1069f467e6fbSJohn Sonnenschein gettail(name) : name; 10707c478bd9Sstevel@tonic-gate val = (pathconf(filename, _PC_XATTR_EXISTS) == 1); 10717c478bd9Sstevel@tonic-gate break; 10727c478bd9Sstevel@tonic-gate case ACL: 10737c478bd9Sstevel@tonic-gate /* 10747c478bd9Sstevel@tonic-gate * Need to get the tail of the file name, since we have 10757c478bd9Sstevel@tonic-gate * already chdir()ed into the directory (performed in 10767c478bd9Sstevel@tonic-gate * nftw()) of the file 10777c478bd9Sstevel@tonic-gate */ 1078f467e6fbSJohn Sonnenschein filename = (walkflags & FTW_CHDIR) ? 1079f467e6fbSJohn Sonnenschein gettail(name) : name; 1080f467e6fbSJohn Sonnenschein val = acl_trivial(filename); 10817c478bd9Sstevel@tonic-gate break; 1082b34cd89aSYuri Pankov case F_USERACL: 1083b34cd89aSYuri Pankov case F_GROUPACL: { 1084b34cd89aSYuri Pankov int i; 1085b34cd89aSYuri Pankov acl_t *acl; 1086b34cd89aSYuri Pankov void *acl_entry; 1087b34cd89aSYuri Pankov aclent_t *p1; 1088b34cd89aSYuri Pankov ace_t *p2; 1089b34cd89aSYuri Pankov 1090b34cd89aSYuri Pankov filename = (walkflags & FTW_CHDIR) ? 1091b34cd89aSYuri Pankov gettail(name) : name; 1092b34cd89aSYuri Pankov val = 0; 1093b34cd89aSYuri Pankov if (acl_get(filename, 0, &acl) != 0) 1094b34cd89aSYuri Pankov break; 1095b34cd89aSYuri Pankov for (i = 0, acl_entry = acl->acl_aclp; 1096b34cd89aSYuri Pankov i != acl->acl_cnt; i++) { 1097b34cd89aSYuri Pankov if (acl->acl_type == ACLENT_T) { 1098b34cd89aSYuri Pankov p1 = (aclent_t *)acl_entry; 1099b34cd89aSYuri Pankov if (p1->a_id == np->first.l) { 1100b34cd89aSYuri Pankov val = 1; 1101b34cd89aSYuri Pankov acl_free(acl); 1102b34cd89aSYuri Pankov break; 1103b34cd89aSYuri Pankov } 1104b34cd89aSYuri Pankov } else { 1105b34cd89aSYuri Pankov p2 = (ace_t *)acl_entry; 1106b34cd89aSYuri Pankov if (p2->a_who == np->first.l) { 1107b34cd89aSYuri Pankov val = 1; 1108b34cd89aSYuri Pankov acl_free(acl); 1109b34cd89aSYuri Pankov break; 1110b34cd89aSYuri Pankov } 1111b34cd89aSYuri Pankov } 1112b34cd89aSYuri Pankov acl_entry = ((char *)acl_entry + 1113b34cd89aSYuri Pankov acl->acl_entry_size); 1114b34cd89aSYuri Pankov } 1115b34cd89aSYuri Pankov acl_free(acl); 1116b34cd89aSYuri Pankov break; 1117b34cd89aSYuri Pankov } 1118b34cd89aSYuri Pankov case IREGEX: 1119b34cd89aSYuri Pankov case REGEX: { 1120b34cd89aSYuri Pankov regmatch_t pmatch; 1121b34cd89aSYuri Pankov 1122b34cd89aSYuri Pankov val = 0; 1123b34cd89aSYuri Pankov if (regexec(&preg[cnpreg], name, 1, &pmatch, NULL) == 0) 1124b34cd89aSYuri Pankov val = ((pmatch.rm_so == 0) && 1125b34cd89aSYuri Pankov (pmatch.rm_eo == strlen(name))); 1126b34cd89aSYuri Pankov cnpreg++; 1127b34cd89aSYuri Pankov break; 1128b34cd89aSYuri Pankov } 1129b34cd89aSYuri Pankov case MAXDEPTH: 1130b34cd89aSYuri Pankov if (state->level == maxdepth && type == FTW_D) 1131b34cd89aSYuri Pankov state->quit = FTW_PRUNE; 1132b34cd89aSYuri Pankov /* FALLTHROUGH */ 1133b34cd89aSYuri Pankov case MINDEPTH: 1134b34cd89aSYuri Pankov val = 1; 1135b34cd89aSYuri Pankov break; 11367c478bd9Sstevel@tonic-gate } 11377c478bd9Sstevel@tonic-gate /* 11387c478bd9Sstevel@tonic-gate * evaluate 'val' and 'not' (exclusive-or) 11397c478bd9Sstevel@tonic-gate * if no inversion (not == 1), return only when val == 0 11407c478bd9Sstevel@tonic-gate * (primary not true). Otherwise, invert the primary 11417c478bd9Sstevel@tonic-gate * and return when the primary is true. 11427c478bd9Sstevel@tonic-gate * 'Lastval' saves the last result (fail or pass) when 11437c478bd9Sstevel@tonic-gate * returning back to the calling routine. 11447c478bd9Sstevel@tonic-gate */ 11457c478bd9Sstevel@tonic-gate if (val^not) { 11467c478bd9Sstevel@tonic-gate lastval = 0; 11477c478bd9Sstevel@tonic-gate return (0); 11487c478bd9Sstevel@tonic-gate } 11497c478bd9Sstevel@tonic-gate lastval = 1; 11507c478bd9Sstevel@tonic-gate not = 1; 11517c478bd9Sstevel@tonic-gate np = np->next; 11527c478bd9Sstevel@tonic-gate } 11537c478bd9Sstevel@tonic-gate return (0); 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate /* 11577c478bd9Sstevel@tonic-gate * code for the -ok option 11587c478bd9Sstevel@tonic-gate */ 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate static int 11617c478bd9Sstevel@tonic-gate ok(name, argv) 11627c478bd9Sstevel@tonic-gate char *name; 11637c478bd9Sstevel@tonic-gate char *argv[]; 11647c478bd9Sstevel@tonic-gate { 11653d63ea05Sas int c; 11663d63ea05Sas int i = 0; 11673d63ea05Sas char resp[LINE_MAX + 1]; 11687c478bd9Sstevel@tonic-gate 11697c478bd9Sstevel@tonic-gate (void) fflush(stdout); /* to flush possible `-print' */ 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate if ((*argv != dummyarg) && (strcmp(*argv, name))) 11727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "< %s ... %s >? ", *argv, name); 11737c478bd9Sstevel@tonic-gate else 11747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "< {} ... %s >? ", name); 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate (void) fflush(stderr); 11773d63ea05Sas 11783d63ea05Sas while ((c = getchar()) != '\n') { 11797c478bd9Sstevel@tonic-gate if (c == EOF) 11807c478bd9Sstevel@tonic-gate exit(2); 11813d63ea05Sas if (i < LINE_MAX) 11823d63ea05Sas resp[i++] = c; 11833d63ea05Sas } 11843d63ea05Sas resp[i] = '\0'; 11853d63ea05Sas 11863d63ea05Sas if (yes_check(resp)) 11873d63ea05Sas return (doexec(name, argv, NULL)); 11883d63ea05Sas else 11893d63ea05Sas return (0); 11907c478bd9Sstevel@tonic-gate } 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate /* 11937c478bd9Sstevel@tonic-gate * execute argv with {} replaced by name 1194d35170d6Srm * 1195d35170d6Srm * Per XPG6, find must exit non-zero if an invocation through 1196d35170d6Srm * -exec, punctuated by a plus sign, exits non-zero, so set 1197d35170d6Srm * exitcode if we see a non-zero exit. 1198d35170d6Srm * exitcode should be NULL when -exec or -ok is not punctuated 1199d35170d6Srm * by a plus sign. 12007c478bd9Sstevel@tonic-gate */ 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate static int 1203d35170d6Srm doexec(char *name, char *argv[], int *exitcode) 12047c478bd9Sstevel@tonic-gate { 12057c478bd9Sstevel@tonic-gate char *cp; 12067c478bd9Sstevel@tonic-gate char **av = argv; 1207d35170d6Srm char *newargs[1 + SHELL_MAXARGS + 1]; 12087c478bd9Sstevel@tonic-gate int dummyseen = 0; 1209d35170d6Srm int i, j, status, rc, r = 0; 1210d35170d6Srm int exit_status = 0; 1211d35170d6Srm pid_t pid, pid1; 12127c478bd9Sstevel@tonic-gate 12137c478bd9Sstevel@tonic-gate (void) fflush(stdout); /* to flush possible `-print' */ 12147c478bd9Sstevel@tonic-gate if (name) { 12157c478bd9Sstevel@tonic-gate while (cp = *av++) { 12167c478bd9Sstevel@tonic-gate if (cp == dummyarg) { 12177c478bd9Sstevel@tonic-gate dummyseen = 1; 12187c478bd9Sstevel@tonic-gate av[-1] = name; 12197c478bd9Sstevel@tonic-gate } 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate if (argv[0] == NULL) /* null command line */ 12247c478bd9Sstevel@tonic-gate return (r); 12257c478bd9Sstevel@tonic-gate 1226d35170d6Srm if ((pid = fork()) == -1) { 1227d35170d6Srm /* fork failed */ 1228d35170d6Srm if (exitcode != NULL) 1229d35170d6Srm *exitcode = 1; 1230d35170d6Srm return (0); 1231d35170d6Srm } 1232d35170d6Srm if (pid != 0) { 1233d35170d6Srm /* parent */ 1234d35170d6Srm do { 1235d35170d6Srm /* wait for child to exit */ 1236d35170d6Srm if ((rc = wait(&r)) == -1 && errno != EINTR) { 1237d35170d6Srm (void) fprintf(stderr, 1238d35170d6Srm gettext("wait failed %s"), strerror(errno)); 1239d35170d6Srm 1240d35170d6Srm if (exitcode != NULL) 1241d35170d6Srm *exitcode = 1; 1242d35170d6Srm return (0); 1243d35170d6Srm } 1244d35170d6Srm } while (rc != pid); 1245d35170d6Srm } else { 1246d35170d6Srm /* child */ 12477c478bd9Sstevel@tonic-gate (void) execvp(argv[0], argv); 1248d35170d6Srm if (errno != E2BIG) 1249d35170d6Srm exit(1); 1250d35170d6Srm 1251d35170d6Srm /* 1252d35170d6Srm * We are in a situation where argv[0] points to a 1253d35170d6Srm * script without the interpreter line, e.g. #!/bin/sh. 1254d35170d6Srm * execvp() will execute either /usr/bin/sh or 1255d35170d6Srm * /usr/xpg4/bin/sh against the script, and you will be 1256d35170d6Srm * limited to SHELL_MAXARGS arguments. If you try to 1257d35170d6Srm * pass more than SHELL_MAXARGS arguments, execvp() 1258d35170d6Srm * fails with E2BIG. 1259d35170d6Srm * See usr/src/lib/libc/port/gen/execvp.c. 1260d35170d6Srm * 1261d35170d6Srm * In this situation, process the argument list by 1262d35170d6Srm * packets of SHELL_MAXARGS arguments with respect of 1263d35170d6Srm * the following rules: 1264d35170d6Srm * 1. the invocations have to complete before find exits 1265d35170d6Srm * 2. only one invocation can be running at a time 1266d35170d6Srm */ 1267d35170d6Srm 1268d35170d6Srm i = 1; 1269d35170d6Srm newargs[0] = argv[0]; 1270d35170d6Srm 1271d35170d6Srm while (argv[i]) { 1272d35170d6Srm j = 1; 1273d35170d6Srm while (j <= SHELL_MAXARGS && argv[i]) { 1274d35170d6Srm newargs[j++] = argv[i++]; 1275d35170d6Srm } 1276d35170d6Srm newargs[j] = NULL; 1277d35170d6Srm 1278d35170d6Srm if ((pid1 = fork()) == -1) { 1279d35170d6Srm /* fork failed */ 1280d35170d6Srm exit(1); 1281d35170d6Srm } 1282d35170d6Srm if (pid1 == 0) { 1283d35170d6Srm /* child */ 1284d35170d6Srm (void) execvp(newargs[0], newargs); 1285d35170d6Srm exit(1); 1286d35170d6Srm } 1287d35170d6Srm 1288d35170d6Srm status = 0; 1289d35170d6Srm 1290d35170d6Srm do { 1291d35170d6Srm /* wait for the child to exit */ 1292d35170d6Srm if ((rc = wait(&status)) == -1 && 1293d35170d6Srm errno != EINTR) { 1294d35170d6Srm (void) fprintf(stderr, 1295d35170d6Srm gettext("wait failed %s"), 1296d35170d6Srm strerror(errno)); 1297d35170d6Srm exit(1); 1298d35170d6Srm } 1299d35170d6Srm } while (rc != pid1); 1300d35170d6Srm 1301d35170d6Srm if (status) 1302d35170d6Srm exit_status = 1; 1303d35170d6Srm } 1304d35170d6Srm /* all the invocations have completed */ 1305d35170d6Srm exit(exit_status); 13067c478bd9Sstevel@tonic-gate } 1307d35170d6Srm 13087c478bd9Sstevel@tonic-gate if (name && dummyseen) { 13097c478bd9Sstevel@tonic-gate for (av = argv; cp = *av++; ) { 13107c478bd9Sstevel@tonic-gate if (cp == name) 13117c478bd9Sstevel@tonic-gate av[-1] = dummyarg; 13127c478bd9Sstevel@tonic-gate } 13137c478bd9Sstevel@tonic-gate } 13147c478bd9Sstevel@tonic-gate 1315d35170d6Srm if (r && exitcode != NULL) 1316d35170d6Srm *exitcode = 3; /* use to indicate error in cmd invocation */ 1317d35170d6Srm 13187c478bd9Sstevel@tonic-gate return (!r); 13197c478bd9Sstevel@tonic-gate } 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate 13227c478bd9Sstevel@tonic-gate /* 13237c478bd9Sstevel@tonic-gate * Table lookup routine 13247c478bd9Sstevel@tonic-gate */ 13257c478bd9Sstevel@tonic-gate static struct Args * 13267c478bd9Sstevel@tonic-gate lookup(word) 13277c478bd9Sstevel@tonic-gate char *word; 13287c478bd9Sstevel@tonic-gate { 13297c478bd9Sstevel@tonic-gate struct Args *argp = commands; 13307c478bd9Sstevel@tonic-gate int second; 13317c478bd9Sstevel@tonic-gate if (word == 0 || *word == 0) 13327c478bd9Sstevel@tonic-gate return (0); 13337c478bd9Sstevel@tonic-gate second = word[1]; 13347c478bd9Sstevel@tonic-gate while (*argp->name) { 13357c478bd9Sstevel@tonic-gate if (second == argp->name[1] && strcmp(word, argp->name) == 0) 13367c478bd9Sstevel@tonic-gate return (argp); 13377c478bd9Sstevel@tonic-gate argp++; 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate return (0); 13407c478bd9Sstevel@tonic-gate } 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate /* 13447c478bd9Sstevel@tonic-gate * Get space for variable length argument list 13457c478bd9Sstevel@tonic-gate */ 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate static struct Arglist * 13487c478bd9Sstevel@tonic-gate varargs(com) 13497c478bd9Sstevel@tonic-gate char **com; 13507c478bd9Sstevel@tonic-gate { 13517c478bd9Sstevel@tonic-gate struct Arglist *ap; 13527c478bd9Sstevel@tonic-gate int n; 13537c478bd9Sstevel@tonic-gate char **ep; 13547c478bd9Sstevel@tonic-gate if (varsize == 0) { 13557c478bd9Sstevel@tonic-gate n = 2*sizeof (char **); 13567c478bd9Sstevel@tonic-gate for (ep = environ; *ep; ep++) 13577c478bd9Sstevel@tonic-gate n += (strlen(*ep)+sizeof (ep) + 1); 13587c478bd9Sstevel@tonic-gate varsize = sizeof (struct Arglist)+ARG_MAX-PATH_MAX-n-1; 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate ap = (struct Arglist *)malloc(varsize+1); 13617c478bd9Sstevel@tonic-gate ap->end = (char *)ap + varsize; 13627c478bd9Sstevel@tonic-gate ap->nextstr = ap->end; 13637c478bd9Sstevel@tonic-gate ap->nextvar = ap->arglist; 13647c478bd9Sstevel@tonic-gate while (*ap->nextvar++ = *com++); 13657c478bd9Sstevel@tonic-gate ap->nextvar--; 13667c478bd9Sstevel@tonic-gate ap->firstvar = ap->nextvar; 13677c478bd9Sstevel@tonic-gate ap->next = lastlist; 13687c478bd9Sstevel@tonic-gate lastlist = ap; 13697c478bd9Sstevel@tonic-gate return (ap); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate /* 13737c478bd9Sstevel@tonic-gate * filter command support 13747c478bd9Sstevel@tonic-gate * fork and exec cmd(argv) according to mode: 13757c478bd9Sstevel@tonic-gate * 13767c478bd9Sstevel@tonic-gate * "r" with fp as stdin of cmd (default stdin), cmd stdout returned 13777c478bd9Sstevel@tonic-gate * "w" with fp as stdout of cmd (default stdout), cmd stdin returned 13787c478bd9Sstevel@tonic-gate */ 13797c478bd9Sstevel@tonic-gate 13807c478bd9Sstevel@tonic-gate #define CMDERR ((1<<8)-1) /* command error exit code */ 13817c478bd9Sstevel@tonic-gate #define MAXCMDS 8 /* max # simultaneous cmdopen()'s */ 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate static struct /* info for each cmdopen() */ 13847c478bd9Sstevel@tonic-gate { 13857c478bd9Sstevel@tonic-gate FILE *fp; /* returned by cmdopen() */ 13867c478bd9Sstevel@tonic-gate pid_t pid; /* pid used by cmdopen() */ 13877c478bd9Sstevel@tonic-gate } cmdproc[MAXCMDS]; 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate static FILE * 13907c478bd9Sstevel@tonic-gate cmdopen(cmd, argv, mode, fp) 13917c478bd9Sstevel@tonic-gate char *cmd; 13927c478bd9Sstevel@tonic-gate char **argv; 13937c478bd9Sstevel@tonic-gate char *mode; 13947c478bd9Sstevel@tonic-gate FILE *fp; 13957c478bd9Sstevel@tonic-gate { 13967c478bd9Sstevel@tonic-gate int proc; 13977c478bd9Sstevel@tonic-gate int cmdfd; 13987c478bd9Sstevel@tonic-gate int usrfd; 13997c478bd9Sstevel@tonic-gate int pio[2]; 14007c478bd9Sstevel@tonic-gate 14017c478bd9Sstevel@tonic-gate switch (*mode) { 14027c478bd9Sstevel@tonic-gate case 'r': 14037c478bd9Sstevel@tonic-gate cmdfd = 1; 14047c478bd9Sstevel@tonic-gate usrfd = 0; 14057c478bd9Sstevel@tonic-gate break; 14067c478bd9Sstevel@tonic-gate case 'w': 14077c478bd9Sstevel@tonic-gate cmdfd = 0; 14087c478bd9Sstevel@tonic-gate usrfd = 1; 14097c478bd9Sstevel@tonic-gate break; 14107c478bd9Sstevel@tonic-gate default: 14117c478bd9Sstevel@tonic-gate return (0); 14127c478bd9Sstevel@tonic-gate } 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate for (proc = 0; proc < MAXCMDS; proc++) 14157c478bd9Sstevel@tonic-gate if (!cmdproc[proc].fp) 14167c478bd9Sstevel@tonic-gate break; 14177c478bd9Sstevel@tonic-gate if (proc >= MAXCMDS) 14187c478bd9Sstevel@tonic-gate return (0); 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate if (pipe(pio)) 14217c478bd9Sstevel@tonic-gate return (0); 14227c478bd9Sstevel@tonic-gate 14237c478bd9Sstevel@tonic-gate switch (cmdproc[proc].pid = fork()) { 14247c478bd9Sstevel@tonic-gate case -1: 14257c478bd9Sstevel@tonic-gate return (0); 14267c478bd9Sstevel@tonic-gate case 0: 14277c478bd9Sstevel@tonic-gate if (fp && fileno(fp) != usrfd) { 14287c478bd9Sstevel@tonic-gate (void) close(usrfd); 14297c478bd9Sstevel@tonic-gate if (dup2(fileno(fp), usrfd) != usrfd) 14307c478bd9Sstevel@tonic-gate _exit(CMDERR); 14317c478bd9Sstevel@tonic-gate (void) close(fileno(fp)); 14327c478bd9Sstevel@tonic-gate } 14337c478bd9Sstevel@tonic-gate (void) close(cmdfd); 14347c478bd9Sstevel@tonic-gate if (dup2(pio[cmdfd], cmdfd) != cmdfd) 14357c478bd9Sstevel@tonic-gate _exit(CMDERR); 14367c478bd9Sstevel@tonic-gate (void) close(pio[cmdfd]); 14377c478bd9Sstevel@tonic-gate (void) close(pio[usrfd]); 14387c478bd9Sstevel@tonic-gate (void) execvp(cmd, argv); 14397c478bd9Sstevel@tonic-gate if (errno == ENOEXEC) { 14407c478bd9Sstevel@tonic-gate char **p; 14417c478bd9Sstevel@tonic-gate char **v; 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * assume cmd is a shell script 14457c478bd9Sstevel@tonic-gate */ 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate p = argv; 14487c478bd9Sstevel@tonic-gate while (*p++); 14497c478bd9Sstevel@tonic-gate if (v = (char **)malloc((p - argv + 1) * 14507c478bd9Sstevel@tonic-gate sizeof (char **))) { 14517c478bd9Sstevel@tonic-gate p = v; 14527c478bd9Sstevel@tonic-gate *p++ = cmd; 14537c478bd9Sstevel@tonic-gate if (*argv) argv++; 14547c478bd9Sstevel@tonic-gate while (*p++ = *argv++); 14557c478bd9Sstevel@tonic-gate (void) execv(getshell(), v); 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate } 14587c478bd9Sstevel@tonic-gate _exit(CMDERR); 14597c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 14607c478bd9Sstevel@tonic-gate default: 14617c478bd9Sstevel@tonic-gate (void) close(pio[cmdfd]); 14627c478bd9Sstevel@tonic-gate return (cmdproc[proc].fp = fdopen(pio[usrfd], mode)); 14637c478bd9Sstevel@tonic-gate } 14647c478bd9Sstevel@tonic-gate } 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate /* 14677c478bd9Sstevel@tonic-gate * close a stream opened by cmdopen() 14687c478bd9Sstevel@tonic-gate * -1 returned if cmdopen() had a problem 14697c478bd9Sstevel@tonic-gate * otherwise exit() status of command is returned 14707c478bd9Sstevel@tonic-gate */ 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate static int 14737c478bd9Sstevel@tonic-gate cmdclose(fp) 14747c478bd9Sstevel@tonic-gate FILE *fp; 14757c478bd9Sstevel@tonic-gate { 14767c478bd9Sstevel@tonic-gate int i; 14777c478bd9Sstevel@tonic-gate pid_t p, pid; 14787c478bd9Sstevel@tonic-gate int status; 14797c478bd9Sstevel@tonic-gate 14807c478bd9Sstevel@tonic-gate for (i = 0; i < MAXCMDS; i++) 14817c478bd9Sstevel@tonic-gate if (fp == cmdproc[i].fp) break; 14827c478bd9Sstevel@tonic-gate if (i >= MAXCMDS) 14837c478bd9Sstevel@tonic-gate return (-1); 14847c478bd9Sstevel@tonic-gate (void) fclose(fp); 14857c478bd9Sstevel@tonic-gate cmdproc[i].fp = 0; 14867c478bd9Sstevel@tonic-gate pid = cmdproc[i].pid; 14877c478bd9Sstevel@tonic-gate while ((p = wait(&status)) != pid && p != (pid_t)-1); 14887c478bd9Sstevel@tonic-gate if (p == pid) { 14897c478bd9Sstevel@tonic-gate status = (status >> 8) & CMDERR; 14907c478bd9Sstevel@tonic-gate if (status == CMDERR) 14917c478bd9Sstevel@tonic-gate status = -1; 14927c478bd9Sstevel@tonic-gate } 14937c478bd9Sstevel@tonic-gate else 14947c478bd9Sstevel@tonic-gate status = -1; 14957c478bd9Sstevel@tonic-gate return (status); 14967c478bd9Sstevel@tonic-gate } 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate /* 14997c478bd9Sstevel@tonic-gate * return pointer to the full path name of the shell 15007c478bd9Sstevel@tonic-gate * 15017c478bd9Sstevel@tonic-gate * SHELL is read from the environment and must start with / 15027c478bd9Sstevel@tonic-gate * 15037c478bd9Sstevel@tonic-gate * if set-uid or set-gid then the executable and its containing 15047c478bd9Sstevel@tonic-gate * directory must not be writable by the real user 15057c478bd9Sstevel@tonic-gate * 15067c478bd9Sstevel@tonic-gate * /usr/bin/sh is returned by default 15077c478bd9Sstevel@tonic-gate */ 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate char * 15107c478bd9Sstevel@tonic-gate getshell() 15117c478bd9Sstevel@tonic-gate { 15127c478bd9Sstevel@tonic-gate char *s; 15137c478bd9Sstevel@tonic-gate char *sh; 15147c478bd9Sstevel@tonic-gate uid_t u; 15157c478bd9Sstevel@tonic-gate int j; 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate if (((sh = getenv("SHELL")) != 0) && *sh == '/') { 15187c478bd9Sstevel@tonic-gate if (u = getuid()) { 15197c478bd9Sstevel@tonic-gate if ((u != geteuid() || getgid() != getegid()) && 15203d63ea05Sas access(sh, 2) == 0) 15217c478bd9Sstevel@tonic-gate goto defshell; 15227c478bd9Sstevel@tonic-gate s = strrchr(sh, '/'); 15237c478bd9Sstevel@tonic-gate *s = 0; 15247c478bd9Sstevel@tonic-gate j = access(sh, 2); 15257c478bd9Sstevel@tonic-gate *s = '/'; 15267c478bd9Sstevel@tonic-gate if (!j) goto defshell; 15277c478bd9Sstevel@tonic-gate } 15287c478bd9Sstevel@tonic-gate return (sh); 15297c478bd9Sstevel@tonic-gate } 15307c478bd9Sstevel@tonic-gate defshell: 15317c478bd9Sstevel@tonic-gate return ("/usr/bin/sh"); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate /* 15357c478bd9Sstevel@tonic-gate * the following functions implement the added "-ls" option 15367c478bd9Sstevel@tonic-gate */ 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate #include <utmpx.h> 15397c478bd9Sstevel@tonic-gate #include <sys/mkdev.h> 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate struct utmpx utmpx; 15427c478bd9Sstevel@tonic-gate #define NMAX (sizeof (utmpx.ut_name)) 15437c478bd9Sstevel@tonic-gate #define SCPYN(a, b) (void) strncpy(a, b, NMAX) 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate #define NUID 64 15467c478bd9Sstevel@tonic-gate #define NGID 64 15477c478bd9Sstevel@tonic-gate 15487c478bd9Sstevel@tonic-gate static struct ncache { 15497c478bd9Sstevel@tonic-gate int id; 15507c478bd9Sstevel@tonic-gate char name[NMAX+1]; 15517c478bd9Sstevel@tonic-gate } nc[NUID], gc[NGID]; 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate /* 15547c478bd9Sstevel@tonic-gate * This function assumes that the password file is hashed 15557c478bd9Sstevel@tonic-gate * (or some such) to allow fast access based on a name key. 15567c478bd9Sstevel@tonic-gate */ 15577c478bd9Sstevel@tonic-gate static char * 15587c478bd9Sstevel@tonic-gate getname(uid_t uid) 15597c478bd9Sstevel@tonic-gate { 15607c478bd9Sstevel@tonic-gate struct passwd *pw; 15617c478bd9Sstevel@tonic-gate int cp; 15627c478bd9Sstevel@tonic-gate 15637c478bd9Sstevel@tonic-gate #if (((NUID) & ((NUID) - 1)) != 0) 15647c478bd9Sstevel@tonic-gate cp = uid % (NUID); 15657c478bd9Sstevel@tonic-gate #else 15667c478bd9Sstevel@tonic-gate cp = uid & ((NUID) - 1); 15677c478bd9Sstevel@tonic-gate #endif 1568f48205beScasper if (nc[cp].id == uid && nc[cp].name[0]) 15697c478bd9Sstevel@tonic-gate return (nc[cp].name); 15707c478bd9Sstevel@tonic-gate pw = getpwuid(uid); 15717c478bd9Sstevel@tonic-gate if (!pw) 15727c478bd9Sstevel@tonic-gate return (0); 15737c478bd9Sstevel@tonic-gate nc[cp].id = uid; 15747c478bd9Sstevel@tonic-gate SCPYN(nc[cp].name, pw->pw_name); 15757c478bd9Sstevel@tonic-gate return (nc[cp].name); 15767c478bd9Sstevel@tonic-gate } 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate /* 15797c478bd9Sstevel@tonic-gate * This function assumes that the group file is hashed 15807c478bd9Sstevel@tonic-gate * (or some such) to allow fast access based on a name key. 15817c478bd9Sstevel@tonic-gate */ 15827c478bd9Sstevel@tonic-gate static char * 15837c478bd9Sstevel@tonic-gate getgroup(gid_t gid) 15847c478bd9Sstevel@tonic-gate { 15857c478bd9Sstevel@tonic-gate struct group *gr; 15867c478bd9Sstevel@tonic-gate int cp; 15877c478bd9Sstevel@tonic-gate 15887c478bd9Sstevel@tonic-gate #if (((NGID) & ((NGID) - 1)) != 0) 15897c478bd9Sstevel@tonic-gate cp = gid % (NGID); 15907c478bd9Sstevel@tonic-gate #else 15917c478bd9Sstevel@tonic-gate cp = gid & ((NGID) - 1); 15927c478bd9Sstevel@tonic-gate #endif 1593f48205beScasper if (gc[cp].id == gid && gc[cp].name[0]) 15947c478bd9Sstevel@tonic-gate return (gc[cp].name); 15957c478bd9Sstevel@tonic-gate gr = getgrgid(gid); 15967c478bd9Sstevel@tonic-gate if (!gr) 15977c478bd9Sstevel@tonic-gate return (0); 15987c478bd9Sstevel@tonic-gate gc[cp].id = gid; 15997c478bd9Sstevel@tonic-gate SCPYN(gc[cp].name, gr->gr_name); 16007c478bd9Sstevel@tonic-gate return (gc[cp].name); 16017c478bd9Sstevel@tonic-gate } 16027c478bd9Sstevel@tonic-gate 16037c478bd9Sstevel@tonic-gate #define permoffset(who) ((who) * 3) 16047c478bd9Sstevel@tonic-gate #define permission(who, type) ((type) >> permoffset(who)) 16057c478bd9Sstevel@tonic-gate #define kbytes(bytes) (((bytes) + 1023) / 1024) 16067c478bd9Sstevel@tonic-gate 16077c478bd9Sstevel@tonic-gate static int 16087c478bd9Sstevel@tonic-gate list(file, stp) 16097c478bd9Sstevel@tonic-gate char *file; 16107c478bd9Sstevel@tonic-gate struct stat *stp; 16117c478bd9Sstevel@tonic-gate { 16127c478bd9Sstevel@tonic-gate char pmode[32], uname[32], gname[32], fsize[32], ftime[32]; 1613fa9e4066Sahrens int trivial; 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate /* 16167c478bd9Sstevel@tonic-gate * Each line below contains the relevant permission (column 1) and character 16177c478bd9Sstevel@tonic-gate * shown when the corresponding execute bit is either clear (column 2) 16187c478bd9Sstevel@tonic-gate * or set (column 3) 16197c478bd9Sstevel@tonic-gate * These permissions are as shown by ls(1b) 16207c478bd9Sstevel@tonic-gate */ 16217c478bd9Sstevel@tonic-gate static long special[] = { S_ISUID, 'S', 's', 16227c478bd9Sstevel@tonic-gate S_ISGID, 'S', 's', 16237c478bd9Sstevel@tonic-gate S_ISVTX, 'T', 't' }; 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate static time_t sixmonthsago = -1; 16267c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 16277c478bd9Sstevel@tonic-gate char flink[MAXPATHLEN + 1]; 16287c478bd9Sstevel@tonic-gate #endif 16297c478bd9Sstevel@tonic-gate int who; 16307c478bd9Sstevel@tonic-gate char *cp; 16317c478bd9Sstevel@tonic-gate char *tailname; 16327c478bd9Sstevel@tonic-gate time_t now; 16337c478bd9Sstevel@tonic-gate long long ksize; 16347c478bd9Sstevel@tonic-gate 16357c478bd9Sstevel@tonic-gate if (file == NULL || stp == NULL) 16367c478bd9Sstevel@tonic-gate return (-1); 16377c478bd9Sstevel@tonic-gate 16387c478bd9Sstevel@tonic-gate (void) time(&now); 16397c478bd9Sstevel@tonic-gate if (sixmonthsago == -1) 16407c478bd9Sstevel@tonic-gate sixmonthsago = now - 6L*30L*24L*60L*60L; 16417c478bd9Sstevel@tonic-gate 16427c478bd9Sstevel@tonic-gate switch (stp->st_mode & S_IFMT) { 16437c478bd9Sstevel@tonic-gate #ifdef S_IFDIR 16447c478bd9Sstevel@tonic-gate case S_IFDIR: /* directory */ 16457c478bd9Sstevel@tonic-gate pmode[0] = 'd'; 16467c478bd9Sstevel@tonic-gate break; 16477c478bd9Sstevel@tonic-gate #endif 16487c478bd9Sstevel@tonic-gate #ifdef S_IFCHR 16497c478bd9Sstevel@tonic-gate case S_IFCHR: /* character special */ 16507c478bd9Sstevel@tonic-gate pmode[0] = 'c'; 16517c478bd9Sstevel@tonic-gate break; 16527c478bd9Sstevel@tonic-gate #endif 16537c478bd9Sstevel@tonic-gate #ifdef S_IFBLK 16547c478bd9Sstevel@tonic-gate case S_IFBLK: /* block special */ 16557c478bd9Sstevel@tonic-gate pmode[0] = 'b'; 16567c478bd9Sstevel@tonic-gate break; 16577c478bd9Sstevel@tonic-gate #endif 16587c478bd9Sstevel@tonic-gate #ifdef S_IFIFO 16597c478bd9Sstevel@tonic-gate case S_IFIFO: /* fifo special */ 16607c478bd9Sstevel@tonic-gate pmode[0] = 'p'; 16617c478bd9Sstevel@tonic-gate break; 16627c478bd9Sstevel@tonic-gate #endif 16637c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 16647c478bd9Sstevel@tonic-gate case S_IFLNK: /* symbolic link */ 16657c478bd9Sstevel@tonic-gate pmode[0] = 'l'; 16667c478bd9Sstevel@tonic-gate break; 16677c478bd9Sstevel@tonic-gate #endif 16687c478bd9Sstevel@tonic-gate #ifdef S_IFSOCK 16697c478bd9Sstevel@tonic-gate case S_IFSOCK: /* socket */ 16707c478bd9Sstevel@tonic-gate pmode[0] = 's'; 16717c478bd9Sstevel@tonic-gate break; 16727c478bd9Sstevel@tonic-gate #endif 16737c478bd9Sstevel@tonic-gate #ifdef S_IFDOOR 16747c478bd9Sstevel@tonic-gate case S_IFDOOR: /* door */ 16757c478bd9Sstevel@tonic-gate pmode[0] = 'D'; 16767c478bd9Sstevel@tonic-gate break; 16777c478bd9Sstevel@tonic-gate #endif 16787c478bd9Sstevel@tonic-gate #ifdef S_IFREG 16797c478bd9Sstevel@tonic-gate case S_IFREG: /* regular */ 16807c478bd9Sstevel@tonic-gate pmode[0] = '-'; 16817c478bd9Sstevel@tonic-gate break; 16827c478bd9Sstevel@tonic-gate #endif 16837c478bd9Sstevel@tonic-gate default: 16847c478bd9Sstevel@tonic-gate pmode[0] = '?'; 16857c478bd9Sstevel@tonic-gate break; 16867c478bd9Sstevel@tonic-gate } 16877c478bd9Sstevel@tonic-gate 16887c478bd9Sstevel@tonic-gate for (who = 0; who < 3; who++) { 16897c478bd9Sstevel@tonic-gate int is_exec = stp->st_mode & permission(who, S_IEXEC)? 1 : 0; 16907c478bd9Sstevel@tonic-gate 16917c478bd9Sstevel@tonic-gate if (stp->st_mode & permission(who, S_IREAD)) 16927c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = 'r'; 16937c478bd9Sstevel@tonic-gate else 16947c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = '-'; 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate if (stp->st_mode & permission(who, S_IWRITE)) 16977c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 2] = 'w'; 16987c478bd9Sstevel@tonic-gate else 16997c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 2] = '-'; 17007c478bd9Sstevel@tonic-gate 17017c478bd9Sstevel@tonic-gate if (stp->st_mode & special[who * 3]) 17027c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 3] = 17037c478bd9Sstevel@tonic-gate special[who * 3 + 1 + is_exec]; 17047c478bd9Sstevel@tonic-gate else if (is_exec) 17057c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 3] = 'x'; 17067c478bd9Sstevel@tonic-gate else 17077c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 3] = '-'; 17087c478bd9Sstevel@tonic-gate } 17097c478bd9Sstevel@tonic-gate 17107c478bd9Sstevel@tonic-gate /* 17117c478bd9Sstevel@tonic-gate * Need to get the tail of the file name, since we have 17127c478bd9Sstevel@tonic-gate * already chdir()ed into the directory of the file 17137c478bd9Sstevel@tonic-gate */ 17147c478bd9Sstevel@tonic-gate 17157c478bd9Sstevel@tonic-gate tailname = gettail(file); 17167c478bd9Sstevel@tonic-gate 1717fa9e4066Sahrens trivial = acl_trivial(tailname); 1718fa9e4066Sahrens if (trivial == -1) 1719fa9e4066Sahrens trivial = 0; 1720fa9e4066Sahrens 1721fa9e4066Sahrens if (trivial == 1) 17227c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = '+'; 17237c478bd9Sstevel@tonic-gate else 17247c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 1] = ' '; 17257c478bd9Sstevel@tonic-gate 17267c478bd9Sstevel@tonic-gate pmode[permoffset(who) + 2] = '\0'; 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate /* 17297c478bd9Sstevel@tonic-gate * Prepare uname and gname. Always add a space afterwards 17307c478bd9Sstevel@tonic-gate * to keep columns from running together. 17317c478bd9Sstevel@tonic-gate */ 17327c478bd9Sstevel@tonic-gate cp = getname(stp->st_uid); 17337c478bd9Sstevel@tonic-gate if (cp != NULL) 17347c478bd9Sstevel@tonic-gate (void) sprintf(uname, "%-8s ", cp); 17357c478bd9Sstevel@tonic-gate else 1736f48205beScasper (void) sprintf(uname, "%-8u ", stp->st_uid); 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate cp = getgroup(stp->st_gid); 17397c478bd9Sstevel@tonic-gate if (cp != NULL) 17407c478bd9Sstevel@tonic-gate (void) sprintf(gname, "%-8s ", cp); 17417c478bd9Sstevel@tonic-gate else 1742f48205beScasper (void) sprintf(gname, "%-8u ", stp->st_gid); 17437c478bd9Sstevel@tonic-gate 17447c478bd9Sstevel@tonic-gate if (pmode[0] == 'b' || pmode[0] == 'c') 17457c478bd9Sstevel@tonic-gate (void) sprintf(fsize, "%3ld,%4ld", 17467c478bd9Sstevel@tonic-gate major(stp->st_rdev), minor(stp->st_rdev)); 17477c478bd9Sstevel@tonic-gate else { 17487c478bd9Sstevel@tonic-gate (void) sprintf(fsize, (stp->st_size < 100000000) ? 17497c478bd9Sstevel@tonic-gate "%8lld" : "%lld", stp->st_size); 17507c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 17517c478bd9Sstevel@tonic-gate if (pmode[0] == 'l') { 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate who = readlink(tailname, flink, sizeof (flink) - 1); 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate if (who >= 0) 17577c478bd9Sstevel@tonic-gate flink[who] = '\0'; 17587c478bd9Sstevel@tonic-gate else 17597c478bd9Sstevel@tonic-gate flink[0] = '\0'; 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate #endif 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate cp = ctime(&stp->st_mtime); 17657c478bd9Sstevel@tonic-gate if (stp->st_mtime < sixmonthsago || stp->st_mtime > now) 17667c478bd9Sstevel@tonic-gate (void) sprintf(ftime, "%-7.7s %-4.4s", cp + 4, cp + 20); 17677c478bd9Sstevel@tonic-gate else 17687c478bd9Sstevel@tonic-gate (void) sprintf(ftime, "%-12.12s", cp + 4); 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate (void) printf((stp->st_ino < 100000) ? "%5llu " : 17717c478bd9Sstevel@tonic-gate "%llu ", stp->st_ino); /* inode # */ 17727c478bd9Sstevel@tonic-gate #ifdef S_IFSOCK 17737c478bd9Sstevel@tonic-gate ksize = (long long) kbytes(ldbtob(stp->st_blocks)); /* kbytes */ 17747c478bd9Sstevel@tonic-gate #else 17757c478bd9Sstevel@tonic-gate ksize = (long long) kbytes(stp->st_size); /* kbytes */ 17767c478bd9Sstevel@tonic-gate #endif 17777c478bd9Sstevel@tonic-gate (void) printf((ksize < 10000) ? "%4lld " : "%lld ", ksize); 17787c478bd9Sstevel@tonic-gate (void) printf("%s %2ld %s%s%s %s %s%s%s\n", 17797c478bd9Sstevel@tonic-gate pmode, /* protection */ 17807c478bd9Sstevel@tonic-gate stp->st_nlink, /* # of links */ 17817c478bd9Sstevel@tonic-gate uname, /* owner */ 17827c478bd9Sstevel@tonic-gate gname, /* group */ 17837c478bd9Sstevel@tonic-gate fsize, /* # of bytes */ 17847c478bd9Sstevel@tonic-gate ftime, /* modify time */ 17857c478bd9Sstevel@tonic-gate file, /* name */ 17867c478bd9Sstevel@tonic-gate #ifdef S_IFLNK 17877c478bd9Sstevel@tonic-gate (pmode[0] == 'l') ? " -> " : "", 17887c478bd9Sstevel@tonic-gate (pmode[0] == 'l') ? flink : "" /* symlink */ 17897c478bd9Sstevel@tonic-gate #else 17907c478bd9Sstevel@tonic-gate "", 17917c478bd9Sstevel@tonic-gate "" 17927c478bd9Sstevel@tonic-gate #endif 17937c478bd9Sstevel@tonic-gate ); 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate return (0); 17967c478bd9Sstevel@tonic-gate } 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate static char * 17997c478bd9Sstevel@tonic-gate new_string(char *s) 18007c478bd9Sstevel@tonic-gate { 18017c478bd9Sstevel@tonic-gate char *p = strdup(s); 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate if (p) 18047c478bd9Sstevel@tonic-gate return (p); 18057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); 18067c478bd9Sstevel@tonic-gate exit(1); 18077c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 18087c478bd9Sstevel@tonic-gate } 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate /* 18117c478bd9Sstevel@tonic-gate * Read remote file system types from REMOTE_FS into the 18127c478bd9Sstevel@tonic-gate * remote_fstypes array. 18137c478bd9Sstevel@tonic-gate */ 18147c478bd9Sstevel@tonic-gate static void 18157c478bd9Sstevel@tonic-gate init_remote_fs() 18167c478bd9Sstevel@tonic-gate { 18177c478bd9Sstevel@tonic-gate FILE *fp; 18187c478bd9Sstevel@tonic-gate char line_buf[LINEBUF_SIZE]; 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate if ((fp = fopen(REMOTE_FS, "r")) == NULL) { 18217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 18223d63ea05Sas gettext("%s: Warning: can't open %s, ignored\n"), 18233d63ea05Sas REMOTE_FS, cmdname); 18247c478bd9Sstevel@tonic-gate /* Use default string name for NFS */ 18257c478bd9Sstevel@tonic-gate remote_fstypes[fstype_index++] = "nfs"; 18267c478bd9Sstevel@tonic-gate return; 18277c478bd9Sstevel@tonic-gate } 18287c478bd9Sstevel@tonic-gate 18297c478bd9Sstevel@tonic-gate while (fgets(line_buf, sizeof (line_buf), fp) != NULL) { 18307c478bd9Sstevel@tonic-gate char buf[LINEBUF_SIZE]; 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate /* LINTED - unbounded string specifier */ 18337c478bd9Sstevel@tonic-gate (void) sscanf(line_buf, "%s", buf); 18347c478bd9Sstevel@tonic-gate remote_fstypes[fstype_index++] = new_string(buf); 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate if (fstype_index == N_FSTYPES) 18377c478bd9Sstevel@tonic-gate break; 18387c478bd9Sstevel@tonic-gate } 18397c478bd9Sstevel@tonic-gate (void) fclose(fp); 18407c478bd9Sstevel@tonic-gate } 18417c478bd9Sstevel@tonic-gate 18427c478bd9Sstevel@tonic-gate #define NPERM 30 /* Largest machine */ 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate /* 18457c478bd9Sstevel@tonic-gate * The PERM struct is the machine that builds permissions. The p_special 18467c478bd9Sstevel@tonic-gate * field contains what permissions need to be checked at run-time in 18477c478bd9Sstevel@tonic-gate * getmode(). This is one of 'X', 'u', 'g', or 'o'. It contains '\0' to 18487c478bd9Sstevel@tonic-gate * indicate normal processing. 18497c478bd9Sstevel@tonic-gate */ 18507c478bd9Sstevel@tonic-gate typedef struct PERMST { 18517c478bd9Sstevel@tonic-gate ushort_t p_who; /* Range of permission (e.g. ugo) */ 18527c478bd9Sstevel@tonic-gate ushort_t p_perm; /* Bits to turn on, off, assign */ 18537c478bd9Sstevel@tonic-gate uchar_t p_op; /* Operation: + - = */ 18547c478bd9Sstevel@tonic-gate uchar_t p_special; /* Special handling? */ 18557c478bd9Sstevel@tonic-gate } PERMST; 18567c478bd9Sstevel@tonic-gate 18577c478bd9Sstevel@tonic-gate #ifndef S_ISVTX 18587c478bd9Sstevel@tonic-gate #define S_ISVTX 0 /* Not .1 */ 18597c478bd9Sstevel@tonic-gate #endif 18607c478bd9Sstevel@tonic-gate 18617c478bd9Sstevel@tonic-gate /* Mask values */ 18627c478bd9Sstevel@tonic-gate #define P_A (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO) /* allbits */ 18637c478bd9Sstevel@tonic-gate #define P_U (S_ISUID|S_ISVTX|S_IRWXU) /* user */ 18647c478bd9Sstevel@tonic-gate #define P_G (S_ISGID|S_ISVTX|S_IRWXG) /* group */ 18657c478bd9Sstevel@tonic-gate #define P_O (S_ISVTX|S_IRWXO) /* other */ 18667c478bd9Sstevel@tonic-gate 18677c478bd9Sstevel@tonic-gate static int iswho(int c); 18687c478bd9Sstevel@tonic-gate static int isop(int c); 18697c478bd9Sstevel@tonic-gate static int isperm(PERMST *pp, int c); 18707c478bd9Sstevel@tonic-gate 18717c478bd9Sstevel@tonic-gate static PERMST machine[NPERM]; /* Permission construction machine */ 18727c478bd9Sstevel@tonic-gate static PERMST *endp; /* Last used PERM structure */ 18737c478bd9Sstevel@tonic-gate 18747c478bd9Sstevel@tonic-gate static uint_t nowho; /* No who for this mode (DOS kludge) */ 18757c478bd9Sstevel@tonic-gate 18767c478bd9Sstevel@tonic-gate /* 18777c478bd9Sstevel@tonic-gate * Read an ASCII string containing the symbolic/octal mode and 18787c478bd9Sstevel@tonic-gate * compile an automaton that recognizes it. The return value 18797c478bd9Sstevel@tonic-gate * is NULL if everything is OK, otherwise it is -1. 18807c478bd9Sstevel@tonic-gate */ 18817c478bd9Sstevel@tonic-gate static int 18827c478bd9Sstevel@tonic-gate readmode(ascmode) 18837c478bd9Sstevel@tonic-gate const char *ascmode; 18847c478bd9Sstevel@tonic-gate { 18857c478bd9Sstevel@tonic-gate const char *amode = ascmode; 18867c478bd9Sstevel@tonic-gate PERMST *pp; 18877c478bd9Sstevel@tonic-gate int seen_X; 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate nowho = 0; 18907c478bd9Sstevel@tonic-gate seen_X = 0; 18917c478bd9Sstevel@tonic-gate pp = &machine[0]; 18927c478bd9Sstevel@tonic-gate if (*amode >= '0' && *amode <= '7') { 18937c478bd9Sstevel@tonic-gate int mode; 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate mode = 0; 18967c478bd9Sstevel@tonic-gate while (*amode >= '0' && *amode <= '7') 18977c478bd9Sstevel@tonic-gate mode = (mode<<3) + *amode++ - '0'; 18987c478bd9Sstevel@tonic-gate if (*amode != '\0') 18997c478bd9Sstevel@tonic-gate return (-1); 19007c478bd9Sstevel@tonic-gate #if S_ISUID != 04000 || S_ISGID != 02000 || \ 19017c478bd9Sstevel@tonic-gate S_IRUSR != 0400 || S_IWUSR != 0200 || S_IXUSR != 0100 || \ 19027c478bd9Sstevel@tonic-gate S_IRGRP != 0040 || S_IWGRP != 0020 || S_IXGRP != 0010 || \ 19037c478bd9Sstevel@tonic-gate S_IROTH != 0004 || S_IWOTH != 0002 || S_IXOTH != 0001 19047c478bd9Sstevel@tonic-gate /* 19057c478bd9Sstevel@tonic-gate * There is no requirement of the octal mode bits being 19067c478bd9Sstevel@tonic-gate * the same as the S_ macros. 19077c478bd9Sstevel@tonic-gate */ 19087c478bd9Sstevel@tonic-gate { 19097c478bd9Sstevel@tonic-gate mode_t mapping[] = { 19107c478bd9Sstevel@tonic-gate S_IXOTH, S_IWOTH, S_IROTH, 19117c478bd9Sstevel@tonic-gate S_IXGRP, S_IWGRP, S_IRGRP, 19127c478bd9Sstevel@tonic-gate S_IXUSR, S_IWUSR, S_IRUSR, 19137c478bd9Sstevel@tonic-gate S_ISGID, S_ISUID, 19147c478bd9Sstevel@tonic-gate 0 19157c478bd9Sstevel@tonic-gate }; 19167c478bd9Sstevel@tonic-gate int i, newmode = 0; 19177c478bd9Sstevel@tonic-gate 19187c478bd9Sstevel@tonic-gate for (i = 0; mapping[i] != 0; i++) 19197c478bd9Sstevel@tonic-gate if (mode & (1<<i)) 19207c478bd9Sstevel@tonic-gate newmode |= mapping[i]; 19217c478bd9Sstevel@tonic-gate mode = newmode; 19227c478bd9Sstevel@tonic-gate } 19237c478bd9Sstevel@tonic-gate #endif 19247c478bd9Sstevel@tonic-gate pp->p_who = P_A; 19257c478bd9Sstevel@tonic-gate pp->p_perm = mode; 19267c478bd9Sstevel@tonic-gate pp->p_op = '='; 19277c478bd9Sstevel@tonic-gate } else for (;;) { 19287c478bd9Sstevel@tonic-gate int t; 19297c478bd9Sstevel@tonic-gate int who = 0; 19307c478bd9Sstevel@tonic-gate 19317c478bd9Sstevel@tonic-gate while ((t = iswho(*amode)) != 0) { 19327c478bd9Sstevel@tonic-gate ++amode; 19337c478bd9Sstevel@tonic-gate who |= t; 19347c478bd9Sstevel@tonic-gate } 19357c478bd9Sstevel@tonic-gate if (who == 0) { 19367c478bd9Sstevel@tonic-gate mode_t currmask; 19377c478bd9Sstevel@tonic-gate (void) umask(currmask = umask((mode_t)0)); 19387c478bd9Sstevel@tonic-gate 19397c478bd9Sstevel@tonic-gate /* 19407c478bd9Sstevel@tonic-gate * If no who specified, must use contents of 19417c478bd9Sstevel@tonic-gate * umask to determine which bits to flip. This 19427c478bd9Sstevel@tonic-gate * is POSIX/V7/BSD behaviour, but not SVID. 19437c478bd9Sstevel@tonic-gate */ 19447c478bd9Sstevel@tonic-gate who = (~currmask)&P_A; 19457c478bd9Sstevel@tonic-gate ++nowho; 19467c478bd9Sstevel@tonic-gate } else 19477c478bd9Sstevel@tonic-gate nowho = 0; 19487c478bd9Sstevel@tonic-gate samewho: 19497c478bd9Sstevel@tonic-gate if (!isop(pp->p_op = *amode++)) 19507c478bd9Sstevel@tonic-gate return (-1); 19517c478bd9Sstevel@tonic-gate pp->p_perm = 0; 19527c478bd9Sstevel@tonic-gate pp->p_special = 0; 19537c478bd9Sstevel@tonic-gate while ((t = isperm(pp, *amode)) != 0) { 19547c478bd9Sstevel@tonic-gate if (pp->p_special == 'X') { 19557c478bd9Sstevel@tonic-gate seen_X = 1; 19567c478bd9Sstevel@tonic-gate 19577c478bd9Sstevel@tonic-gate if (pp->p_perm != 0) { 19587c478bd9Sstevel@tonic-gate ushort_t op; 19597c478bd9Sstevel@tonic-gate 19607c478bd9Sstevel@tonic-gate /* 19617c478bd9Sstevel@tonic-gate * Remember the 'who' for the previous 19627c478bd9Sstevel@tonic-gate * transformation. 19637c478bd9Sstevel@tonic-gate */ 19647c478bd9Sstevel@tonic-gate pp->p_who = who; 19657c478bd9Sstevel@tonic-gate pp->p_special = 0; 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate op = pp->p_op; 19687c478bd9Sstevel@tonic-gate 19697c478bd9Sstevel@tonic-gate /* Keep 'X' separate */ 19707c478bd9Sstevel@tonic-gate ++pp; 19717c478bd9Sstevel@tonic-gate pp->p_special = 'X'; 19727c478bd9Sstevel@tonic-gate pp->p_op = op; 19737c478bd9Sstevel@tonic-gate } 19747c478bd9Sstevel@tonic-gate } else if (seen_X) { 19757c478bd9Sstevel@tonic-gate ushort_t op; 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate /* Remember the 'who' for the X */ 19787c478bd9Sstevel@tonic-gate pp->p_who = who; 19797c478bd9Sstevel@tonic-gate 19807c478bd9Sstevel@tonic-gate op = pp->p_op; 19817c478bd9Sstevel@tonic-gate 19827c478bd9Sstevel@tonic-gate /* Keep 'X' separate */ 19837c478bd9Sstevel@tonic-gate ++pp; 19847c478bd9Sstevel@tonic-gate pp->p_perm = 0; 19857c478bd9Sstevel@tonic-gate pp->p_special = 0; 19867c478bd9Sstevel@tonic-gate pp->p_op = op; 19877c478bd9Sstevel@tonic-gate } 19887c478bd9Sstevel@tonic-gate ++amode; 19897c478bd9Sstevel@tonic-gate pp->p_perm |= t; 19907c478bd9Sstevel@tonic-gate } 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate /* 19937c478bd9Sstevel@tonic-gate * These returned 0, but were actually parsed, so 19947c478bd9Sstevel@tonic-gate * don't look at them again. 19957c478bd9Sstevel@tonic-gate */ 19967c478bd9Sstevel@tonic-gate switch (pp->p_special) { 19977c478bd9Sstevel@tonic-gate case 'u': 19987c478bd9Sstevel@tonic-gate case 'g': 19997c478bd9Sstevel@tonic-gate case 'o': 20007c478bd9Sstevel@tonic-gate ++amode; 20017c478bd9Sstevel@tonic-gate break; 20027c478bd9Sstevel@tonic-gate } 20037c478bd9Sstevel@tonic-gate pp->p_who = who; 20047c478bd9Sstevel@tonic-gate switch (*amode) { 20057c478bd9Sstevel@tonic-gate case '\0': 20067c478bd9Sstevel@tonic-gate break; 20077c478bd9Sstevel@tonic-gate 20087c478bd9Sstevel@tonic-gate case ',': 20097c478bd9Sstevel@tonic-gate ++amode; 20107c478bd9Sstevel@tonic-gate ++pp; 20117c478bd9Sstevel@tonic-gate continue; 20127c478bd9Sstevel@tonic-gate 20137c478bd9Sstevel@tonic-gate default: 20147c478bd9Sstevel@tonic-gate ++pp; 20157c478bd9Sstevel@tonic-gate goto samewho; 20167c478bd9Sstevel@tonic-gate } 20177c478bd9Sstevel@tonic-gate break; 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate endp = pp; 20207c478bd9Sstevel@tonic-gate return (NULL); 20217c478bd9Sstevel@tonic-gate } 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate /* 20247c478bd9Sstevel@tonic-gate * Given a character from the mode, return the associated 20257c478bd9Sstevel@tonic-gate * value as who (user designation) mask or 0 if this isn't valid. 20267c478bd9Sstevel@tonic-gate */ 20277c478bd9Sstevel@tonic-gate static int 20287c478bd9Sstevel@tonic-gate iswho(c) 20297c478bd9Sstevel@tonic-gate int c; 20307c478bd9Sstevel@tonic-gate { 20317c478bd9Sstevel@tonic-gate switch (c) { 20327c478bd9Sstevel@tonic-gate case 'a': 20337c478bd9Sstevel@tonic-gate return (P_A); 20347c478bd9Sstevel@tonic-gate 20357c478bd9Sstevel@tonic-gate case 'u': 20367c478bd9Sstevel@tonic-gate return (P_U); 20377c478bd9Sstevel@tonic-gate 20387c478bd9Sstevel@tonic-gate case 'g': 20397c478bd9Sstevel@tonic-gate return (P_G); 20407c478bd9Sstevel@tonic-gate 20417c478bd9Sstevel@tonic-gate case 'o': 20427c478bd9Sstevel@tonic-gate return (P_O); 20437c478bd9Sstevel@tonic-gate 20447c478bd9Sstevel@tonic-gate default: 20457c478bd9Sstevel@tonic-gate return (0); 20467c478bd9Sstevel@tonic-gate } 20477c478bd9Sstevel@tonic-gate /* NOTREACHED */ 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate /* 20517c478bd9Sstevel@tonic-gate * Return non-zero if this is a valid op code 20527c478bd9Sstevel@tonic-gate * in a symbolic mode. 20537c478bd9Sstevel@tonic-gate */ 20547c478bd9Sstevel@tonic-gate static int 20557c478bd9Sstevel@tonic-gate isop(c) 20567c478bd9Sstevel@tonic-gate int c; 20577c478bd9Sstevel@tonic-gate { 20587c478bd9Sstevel@tonic-gate switch (c) { 20597c478bd9Sstevel@tonic-gate case '+': 20607c478bd9Sstevel@tonic-gate case '-': 20617c478bd9Sstevel@tonic-gate case '=': 20627c478bd9Sstevel@tonic-gate return (1); 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate default: 20657c478bd9Sstevel@tonic-gate return (0); 20667c478bd9Sstevel@tonic-gate } 20677c478bd9Sstevel@tonic-gate /* NOTREACHED */ 20687c478bd9Sstevel@tonic-gate } 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate /* 20717c478bd9Sstevel@tonic-gate * Return the permission bits implied by this character or 0 20727c478bd9Sstevel@tonic-gate * if it isn't valid. Also returns 0 when the pseudo-permissions 'u', 'g', or 20737c478bd9Sstevel@tonic-gate * 'o' are used, and sets pp->p_special to the one used. 20747c478bd9Sstevel@tonic-gate */ 20757c478bd9Sstevel@tonic-gate static int 20767c478bd9Sstevel@tonic-gate isperm(pp, c) 20777c478bd9Sstevel@tonic-gate PERMST *pp; 20787c478bd9Sstevel@tonic-gate int c; 20797c478bd9Sstevel@tonic-gate { 20807c478bd9Sstevel@tonic-gate switch (c) { 20817c478bd9Sstevel@tonic-gate case 'u': 20827c478bd9Sstevel@tonic-gate case 'g': 20837c478bd9Sstevel@tonic-gate case 'o': 20847c478bd9Sstevel@tonic-gate pp->p_special = c; 20857c478bd9Sstevel@tonic-gate return (0); 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate case 'r': 20887c478bd9Sstevel@tonic-gate return (S_IRUSR|S_IRGRP|S_IROTH); 20897c478bd9Sstevel@tonic-gate 20907c478bd9Sstevel@tonic-gate case 'w': 20917c478bd9Sstevel@tonic-gate return (S_IWUSR|S_IWGRP|S_IWOTH); 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate case 'x': 20947c478bd9Sstevel@tonic-gate return (S_IXUSR|S_IXGRP|S_IXOTH); 20957c478bd9Sstevel@tonic-gate 20967c478bd9Sstevel@tonic-gate #if S_ISVTX != 0 20977c478bd9Sstevel@tonic-gate case 't': 20987c478bd9Sstevel@tonic-gate return (S_ISVTX); 20997c478bd9Sstevel@tonic-gate #endif 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate case 'X': 21027c478bd9Sstevel@tonic-gate pp->p_special = 'X'; 21037c478bd9Sstevel@tonic-gate return (S_IXUSR|S_IXGRP|S_IXOTH); 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate #if S_ISVTX != 0 21067c478bd9Sstevel@tonic-gate case 'a': 21077c478bd9Sstevel@tonic-gate return (S_ISVTX); 21087c478bd9Sstevel@tonic-gate #endif 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate case 'h': 21117c478bd9Sstevel@tonic-gate return (S_ISUID); 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate /* 21147c478bd9Sstevel@tonic-gate * This change makes: 21157c478bd9Sstevel@tonic-gate * chmod +s file 21167c478bd9Sstevel@tonic-gate * set the system bit on dos but means that 21177c478bd9Sstevel@tonic-gate * chmod u+s file 21187c478bd9Sstevel@tonic-gate * chmod g+s file 21197c478bd9Sstevel@tonic-gate * chmod a+s file 21207c478bd9Sstevel@tonic-gate * are all like UNIX. 21217c478bd9Sstevel@tonic-gate */ 21227c478bd9Sstevel@tonic-gate case 's': 21237c478bd9Sstevel@tonic-gate return (nowho ? S_ISGID : S_ISGID|S_ISUID); 21247c478bd9Sstevel@tonic-gate 21257c478bd9Sstevel@tonic-gate default: 21267c478bd9Sstevel@tonic-gate return (0); 21277c478bd9Sstevel@tonic-gate } 21287c478bd9Sstevel@tonic-gate /* NOTREACHED */ 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate /* 21327c478bd9Sstevel@tonic-gate * Execute the automaton that is created by readmode() 21337c478bd9Sstevel@tonic-gate * to generate the final mode that will be used. This 21347c478bd9Sstevel@tonic-gate * code is passed a starting mode that is usually the original 21357c478bd9Sstevel@tonic-gate * mode of the file being changed (or 0). Note that this mode must contain 21367c478bd9Sstevel@tonic-gate * the file-type bits as well, so that S_ISDIR will succeed on directories. 21377c478bd9Sstevel@tonic-gate */ 21387c478bd9Sstevel@tonic-gate static mode_t 21397c478bd9Sstevel@tonic-gate getmode(mode_t startmode) 21407c478bd9Sstevel@tonic-gate { 21417c478bd9Sstevel@tonic-gate PERMST *pp; 21427c478bd9Sstevel@tonic-gate mode_t temp; 21437c478bd9Sstevel@tonic-gate mode_t perm; 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate for (pp = &machine[0]; pp <= endp; ++pp) { 21467c478bd9Sstevel@tonic-gate perm = (mode_t)0; 21477c478bd9Sstevel@tonic-gate /* 21487c478bd9Sstevel@tonic-gate * For the special modes 'u', 'g' and 'o', the named portion 21497c478bd9Sstevel@tonic-gate * of the mode refers to after the previous clause has been 21507c478bd9Sstevel@tonic-gate * processed, while the 'X' mode refers to the contents of the 21517c478bd9Sstevel@tonic-gate * mode before any clauses have been processed. 21527c478bd9Sstevel@tonic-gate * 21537c478bd9Sstevel@tonic-gate * References: P1003.2/D11.2, Section 4.7.7, 21547c478bd9Sstevel@tonic-gate * lines 2568-2570, 2578-2583 21557c478bd9Sstevel@tonic-gate */ 21567c478bd9Sstevel@tonic-gate switch (pp->p_special) { 21577c478bd9Sstevel@tonic-gate case 'u': 21587c478bd9Sstevel@tonic-gate temp = startmode & S_IRWXU; 21597c478bd9Sstevel@tonic-gate if (temp & (S_IRUSR|S_IRGRP|S_IROTH)) 21607c478bd9Sstevel@tonic-gate perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & 21617c478bd9Sstevel@tonic-gate pp->p_who); 21627c478bd9Sstevel@tonic-gate if (temp & (S_IWUSR|S_IWGRP|S_IWOTH)) 21637c478bd9Sstevel@tonic-gate perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who); 21647c478bd9Sstevel@tonic-gate if (temp & (S_IXUSR|S_IXGRP|S_IXOTH)) 21657c478bd9Sstevel@tonic-gate perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who); 21667c478bd9Sstevel@tonic-gate break; 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate case 'g': 21697c478bd9Sstevel@tonic-gate temp = startmode & S_IRWXG; 21707c478bd9Sstevel@tonic-gate if (temp & (S_IRUSR|S_IRGRP|S_IROTH)) 21717c478bd9Sstevel@tonic-gate perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & pp->p_who); 21727c478bd9Sstevel@tonic-gate if (temp & (S_IWUSR|S_IWGRP|S_IWOTH)) 21737c478bd9Sstevel@tonic-gate perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who); 21747c478bd9Sstevel@tonic-gate if (temp & (S_IXUSR|S_IXGRP|S_IXOTH)) 21757c478bd9Sstevel@tonic-gate perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who); 21767c478bd9Sstevel@tonic-gate break; 21777c478bd9Sstevel@tonic-gate 21787c478bd9Sstevel@tonic-gate case 'o': 21797c478bd9Sstevel@tonic-gate temp = startmode & S_IRWXO; 21807c478bd9Sstevel@tonic-gate if (temp & (S_IRUSR|S_IRGRP|S_IROTH)) 21817c478bd9Sstevel@tonic-gate perm |= ((S_IRUSR|S_IRGRP|S_IROTH) & pp->p_who); 21827c478bd9Sstevel@tonic-gate if (temp & (S_IWUSR|S_IWGRP|S_IWOTH)) 21837c478bd9Sstevel@tonic-gate perm |= ((S_IWUSR|S_IWGRP|S_IWOTH) & pp->p_who); 21847c478bd9Sstevel@tonic-gate if (temp & (S_IXUSR|S_IXGRP|S_IXOTH)) 21857c478bd9Sstevel@tonic-gate perm |= ((S_IXUSR|S_IXGRP|S_IXOTH) & pp->p_who); 21867c478bd9Sstevel@tonic-gate break; 21877c478bd9Sstevel@tonic-gate 21887c478bd9Sstevel@tonic-gate case 'X': 21897c478bd9Sstevel@tonic-gate perm = pp->p_perm; 21907c478bd9Sstevel@tonic-gate break; 21917c478bd9Sstevel@tonic-gate 21927c478bd9Sstevel@tonic-gate default: 21937c478bd9Sstevel@tonic-gate perm = pp->p_perm; 21947c478bd9Sstevel@tonic-gate break; 21957c478bd9Sstevel@tonic-gate } 21967c478bd9Sstevel@tonic-gate switch (pp->p_op) { 21977c478bd9Sstevel@tonic-gate case '-': 21987c478bd9Sstevel@tonic-gate startmode &= ~(perm & pp->p_who); 21997c478bd9Sstevel@tonic-gate break; 22007c478bd9Sstevel@tonic-gate 22017c478bd9Sstevel@tonic-gate case '=': 22027c478bd9Sstevel@tonic-gate startmode &= ~pp->p_who; 22037c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 22047c478bd9Sstevel@tonic-gate case '+': 22057c478bd9Sstevel@tonic-gate startmode |= (perm & pp->p_who); 22067c478bd9Sstevel@tonic-gate break; 22077c478bd9Sstevel@tonic-gate } 22087c478bd9Sstevel@tonic-gate } 22097c478bd9Sstevel@tonic-gate return (startmode); 22107c478bd9Sstevel@tonic-gate } 22117c478bd9Sstevel@tonic-gate 22127c478bd9Sstevel@tonic-gate /* 22137c478bd9Sstevel@tonic-gate * Returns the last component of a path name, unless it is 22147c478bd9Sstevel@tonic-gate * an absolute path, in which case it returns the whole path 22157c478bd9Sstevel@tonic-gate */ 22167c478bd9Sstevel@tonic-gate static char 22177c478bd9Sstevel@tonic-gate *gettail(char *fname) 22187c478bd9Sstevel@tonic-gate { 22197c478bd9Sstevel@tonic-gate char *base = fname; 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate if (*fname != '/') { 22227c478bd9Sstevel@tonic-gate if ((base = strrchr(fname, '/')) != NULL) 22237c478bd9Sstevel@tonic-gate base++; 22247c478bd9Sstevel@tonic-gate else 22257c478bd9Sstevel@tonic-gate base = fname; 22267c478bd9Sstevel@tonic-gate } 22277c478bd9Sstevel@tonic-gate return (base); 22287c478bd9Sstevel@tonic-gate } 2229