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