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