Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/gen/setmode.c	Lines:	101	162	62.3 %
Date:	2017-11-07	Branches:	51	152	33.6 %


/*	$OpenBSD: setmode.c,v 1.22 2014/10/11 04:14:35 deraadt Exp $	*/
/*	$NetBSD: setmode.c,v 1.15 1997/02/07 22:21:06 christos Exp $	*/

/*
 * Copyright (c) 1989, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Dave Borman at Cray Research, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

#ifdef SETMODE_DEBUG
#include <stdio.h>
#endif

#define	SET_LEN	6		/* initial # of bitcmd struct to malloc */
#define	SET_LEN_INCR 4		/* # of bitcmd structs to add as needed */

typedef struct bitcmd {
	char	cmd;
	char	cmd2;
	mode_t	bits;
} BITCMD;

#define	CMD2_CLR	0x01
#define	CMD2_SET	0x02
#define	CMD2_GBITS	0x04
#define	CMD2_OBITS	0x08
#define	CMD2_UBITS	0x10

static BITCMD	*addcmd(BITCMD *, int, int, int, u_int);
static void	 compress_mode(BITCMD *);
#ifdef SETMODE_DEBUG
static void	 dumpmode(BITCMD *);
#endif

/*
 * Given the old mode and an array of bitcmd structures, apply the operations
 * described in the bitcmd structures to the old mode, and return the new mode.
 * Note that there is no '=' command; a strict assignment is just a '-' (clear
 * bits) followed by a '+' (set bits).
 */
mode_t
getmode(const void *bbox, mode_t omode)
{
	const BITCMD *set;
	mode_t clrval, newmode, value;

	set = (const BITCMD *)bbox;
	newmode = omode;
	for (value = 0;; set++)
		switch(set->cmd) {
		/*
		 * When copying the user, group or other bits around, we "know"
		 * where the bits are in the mode so that we can do shifts to
		 * copy them around.  If we don't use shifts, it gets real
		 * grundgy with lots of single bit checks and bit sets.
		 */
		case 'u':
			value = (newmode & S_IRWXU) >> 6;
			goto common;

		case 'g':
			value = (newmode & S_IRWXG) >> 3;
			goto common;

		case 'o':
			value = newmode & S_IRWXO;
common:			if (set->cmd2 & CMD2_CLR) {
				clrval =
				    (set->cmd2 & CMD2_SET) ?  S_IRWXO : value;
				if (set->cmd2 & CMD2_UBITS)
					newmode &= ~((clrval<<6) & set->bits);
				if (set->cmd2 & CMD2_GBITS)
					newmode &= ~((clrval<<3) & set->bits);
				if (set->cmd2 & CMD2_OBITS)
					newmode &= ~(clrval & set->bits);
			}
			if (set->cmd2 & CMD2_SET) {
				if (set->cmd2 & CMD2_UBITS)
					newmode |= (value<<6) & set->bits;
				if (set->cmd2 & CMD2_GBITS)
					newmode |= (value<<3) & set->bits;
				if (set->cmd2 & CMD2_OBITS)
					newmode |= value & set->bits;
			}
			break;

		case '+':
			newmode |= set->bits;
			break;

		case '-':
			newmode &= ~set->bits;
			break;

		case 'X':
			if (omode & (S_IFDIR|S_IXUSR|S_IXGRP|S_IXOTH))
				newmode |= set->bits;
			break;

		case '\0':
		default:
#ifdef SETMODE_DEBUG
			(void)printf("getmode:%04o -> %04o\n", omode, newmode);
#endif
			return (newmode);
		}
}

#define	ADDCMD(a, b, c, d)						\
	if (set >= endset) {						\
		BITCMD *newset;						\
		setlen += SET_LEN_INCR;					\
		newset = reallocarray(saveset, setlen, sizeof(BITCMD));	\
		if (newset == NULL) {					\
			free(saveset);					\
			return (NULL);					\
		}							\
		set = newset + (set - saveset);				\
		saveset = newset;					\
		endset = newset + (setlen - 2);				\
	}								\
	set = addcmd(set, (a), (b), (c), (d))

#define	STANDARD_BITS	(S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)

void *
setmode(const char *p)
{
	char op, *ep;
	BITCMD *set, *saveset, *endset;
	sigset_t sigset, sigoset;
	mode_t mask, perm, permXbits, who;
	int equalopdone, setlen;
	u_long perml;

	if (!*p) {
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * Get a copy of the mask for the permissions that are mask relative.
	 * Flip the bits, we want what's not set.  Since it's possible that
	 * the caller is opening files inside a signal handler, protect them
	 * as best we can.
	 */
	sigfillset(&sigset);
	(void)sigprocmask(SIG_BLOCK, &sigset, &sigoset);
	(void)umask(mask = umask(0));
	mask = ~mask;
	(void)sigprocmask(SIG_SETMASK, &sigoset, NULL);

	setlen = SET_LEN + 2;

	if ((set = calloc((u_int)sizeof(BITCMD), setlen)) == NULL)
		return (NULL);
	saveset = set;
	endset = set + (setlen - 2);

	/*
	 * If an absolute number, get it and return; disallow non-octal digits
	 * or illegal bits.
	 */
	if (isdigit((unsigned char)*p)) {
		perml = strtoul(p, &ep, 8);
		/* The test on perml will also catch overflow. */
		if (*ep != '\0' || (perml & ~(STANDARD_BITS|S_ISTXT))) {
			free(saveset);
			errno = ERANGE;
			return (NULL);
		}
		perm = (mode_t)perml;
		ADDCMD('=', (STANDARD_BITS|S_ISTXT), perm, mask);
		set->cmd = 0;
		return (saveset);
	}

	/*
	 * Build list of structures to set/clear/copy bits as described by
	 * each clause of the symbolic mode.
	 */
	for (;;) {
		/* First, find out which bits might be modified. */
		for (who = 0;; ++p) {
			switch (*p) {
			case 'a':
				who |= STANDARD_BITS;
				break;
			case 'u':
				who |= S_ISUID|S_IRWXU;
				break;
			case 'g':
				who |= S_ISGID|S_IRWXG;
				break;
			case 'o':
				who |= S_IRWXO;
				break;
			default:
				goto getop;
			}
		}

getop:		if ((op = *p++) != '+' && op != '-' && op != '=') {
			free(saveset);
			errno = EINVAL;
			return (NULL);
		}
		if (op == '=')
			equalopdone = 0;

		who &= ~S_ISTXT;
		for (perm = 0, permXbits = 0;; ++p) {
			switch (*p) {
			case 'r':
				perm |= S_IRUSR|S_IRGRP|S_IROTH;
				break;
			case 's':
				/*
				 * If specific bits where requested and
				 * only "other" bits ignore set-id.
				 */
				if (who == 0 || (who & ~S_IRWXO))
					perm |= S_ISUID|S_ISGID;
				break;
			case 't':
				/*
				 * If specific bits where requested and
				 * only "other" bits ignore sticky.
				 */
				if (who == 0 || (who & ~S_IRWXO)) {
					who |= S_ISTXT;
					perm |= S_ISTXT;
				}
				break;
			case 'w':
				perm |= S_IWUSR|S_IWGRP|S_IWOTH;
				break;
			case 'X':
				permXbits = S_IXUSR|S_IXGRP|S_IXOTH;
				break;
			case 'x':
				perm |= S_IXUSR|S_IXGRP|S_IXOTH;
				break;
			case 'u':
			case 'g':
			case 'o':
				/*
				 * When ever we hit 'u', 'g', or 'o', we have
				 * to flush out any partial mode that we have,
				 * and then do the copying of the mode bits.
				 */
				if (perm) {
					ADDCMD(op, who, perm, mask);
					perm = 0;
				}
				if (op == '=')
					equalopdone = 1;
				if (op == '+' && permXbits) {
					ADDCMD('X', who, permXbits, mask);
					permXbits = 0;
				}
				ADDCMD(*p, who, op, mask);
				break;

			default:
				/*
				 * Add any permissions that we haven't already
				 * done.
				 */
				if (perm || (op == '=' && !equalopdone)) {
					if (op == '=')
						equalopdone = 1;
					ADDCMD(op, who, perm, mask);
					perm = 0;
				}
				if (permXbits) {
					ADDCMD('X', who, permXbits, mask);
					permXbits = 0;
				}
				goto apply;
			}
		}

apply:		if (!*p)
			break;
		if (*p != ',')
			goto getop;
		++p;
	}
	set->cmd = 0;
#ifdef SETMODE_DEBUG
	(void)printf("Before compress_mode()\n");
	dumpmode(saveset);
#endif
	compress_mode(saveset);
#ifdef SETMODE_DEBUG
	(void)printf("After compress_mode()\n");
	dumpmode(saveset);
#endif
	return (saveset);
}

static BITCMD *
addcmd(BITCMD *set, int op, int who, int oparg, u_int mask)
{
	switch (op) {
	case '=':
		set->cmd = '-';
		set->bits = who ? who : STANDARD_BITS;
		set++;

		op = '+';
		/* FALLTHROUGH */
	case '+':
	case '-':
	case 'X':
		set->cmd = op;
		set->bits = (who ? who : mask) & oparg;
		break;

	case 'u':
	case 'g':
	case 'o':
		set->cmd = op;
		if (who) {
			set->cmd2 = ((who & S_IRUSR) ? CMD2_UBITS : 0) |
				    ((who & S_IRGRP) ? CMD2_GBITS : 0) |
				    ((who & S_IROTH) ? CMD2_OBITS : 0);
			set->bits = (mode_t)~0;
		} else {
			set->cmd2 = CMD2_UBITS | CMD2_GBITS | CMD2_OBITS;
			set->bits = mask;
		}

		if (oparg == '+')
			set->cmd2 |= CMD2_SET;
		else if (oparg == '-')
			set->cmd2 |= CMD2_CLR;
		else if (oparg == '=')
			set->cmd2 |= CMD2_SET|CMD2_CLR;
		break;
	}
	return (set + 1);
}

#ifdef SETMODE_DEBUG
static void
dumpmode(BITCMD *set)
{
	for (; set->cmd; ++set)
		(void)printf("cmd: '%c' bits %04o%s%s%s%s%s%s\n",
		    set->cmd, set->bits, set->cmd2 ? " cmd2:" : "",
		    set->cmd2 & CMD2_CLR ? " CLR" : "",
		    set->cmd2 & CMD2_SET ? " SET" : "",
		    set->cmd2 & CMD2_UBITS ? " UBITS" : "",
		    set->cmd2 & CMD2_GBITS ? " GBITS" : "",
		    set->cmd2 & CMD2_OBITS ? " OBITS" : "");
}
#endif

/*
 * Given an array of bitcmd structures, compress by compacting consecutive
 * '+', '-' and 'X' commands into at most 3 commands, one of each.  The 'u',
 * 'g' and 'o' commands continue to be separate.  They could probably be
 * compacted, but it's not worth the effort.
 */
static void
compress_mode(BITCMD *set)
{
	BITCMD *nset;
	int setbits, clrbits, Xbits, op;

	for (nset = set;;) {
		/* Copy over any 'u', 'g' and 'o' commands. */
		while ((op = nset->cmd) != '+' && op != '-' && op != 'X') {
			*set++ = *nset++;
			if (!op)
				return;
		}

		for (setbits = clrbits = Xbits = 0;; nset++) {
			if ((op = nset->cmd) == '-') {
				clrbits |= nset->bits;
				setbits &= ~nset->bits;
				Xbits &= ~nset->bits;
			} else if (op == '+') {
				setbits |= nset->bits;
				clrbits &= ~nset->bits;
				Xbits &= ~nset->bits;
			} else if (op == 'X')
				Xbits |= nset->bits & ~setbits;
			else
				break;
		}
		if (clrbits) {
			set->cmd = '-';
			set->cmd2 = 0;
			set->bits = clrbits;
			set++;
		}
		if (setbits) {
			set->cmd = '+';
			set->cmd2 = 0;
			set->bits = setbits;
			set++;
		}
		if (Xbits) {
			set->cmd = 'X';
			set->cmd2 = 0;
			set->bits = Xbits;
			set++;
		}
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: setmode.c,v 1.22 2014/10/11 04:14:35 deraadt Exp $ */
2			/* $NetBSD: setmode.c,v 1.15 1997/02/07 22:21:06 christos Exp $ */
3
4			/*
5			* Copyright (c) 1989, 1993, 1994
6			* The Regents of the University of California. All rights reserved.
7			*
8			* This code is derived from software contributed to Berkeley by
9			* Dave Borman at Cray Research, Inc.
10			*
11			* Redistribution and use in source and binary forms, with or without
12			* modification, are permitted provided that the following conditions
13			* are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above copyright
17			* notice, this list of conditions and the following disclaimer in the
18			* documentation and/or other materials provided with the distribution.
19			* 3. Neither the name of the University nor the names of its contributors
20			* may be used to endorse or promote products derived from this software
21			* without specific prior written permission.
22			*
23			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33			* SUCH DAMAGE.
34			*/
35
36			#include <sys/types.h>
37			#include <sys/stat.h>
38
39			#include <ctype.h>
40			#include <errno.h>
41			#include <signal.h>
42			#include <stdlib.h>
43			#include <unistd.h>
44
45			#ifdef SETMODE_DEBUG
46			#include <stdio.h>
47			#endif
48
49			#define SET_LEN 6 /* initial # of bitcmd struct to malloc */
50			#define SET_LEN_INCR 4 /* # of bitcmd structs to add as needed */
51
52			typedef struct bitcmd {
53			char cmd;
54			char cmd2;
55			mode_t bits;
56			} BITCMD;
57
58			#define CMD2_CLR 0x01
59			#define CMD2_SET 0x02
60			#define CMD2_GBITS 0x04
61			#define CMD2_OBITS 0x08
62			#define CMD2_UBITS 0x10
63
64			static BITCMD addcmd(BITCMD , int, int, int, u_int);
65			static void compress_mode(BITCMD *);
66			#ifdef SETMODE_DEBUG
67			static void dumpmode(BITCMD *);
68			#endif
69
70			/*
71			* Given the old mode and an array of bitcmd structures, apply the operations
72			* described in the bitcmd structures to the old mode, and return the new mode.
73			* Note that there is no '=' command; a strict assignment is just a '-' (clear
74			* bits) followed by a '+' (set bits).
75			*/
76			mode_t
77			getmode(const void *bbox, mode_t omode)
78			{
79			const BITCMD *set;
80			mode_t clrval, newmode, value;
81
82		4060	set = (const BITCMD *)bbox;
83			newmode = omode;
84		5953	for (value = 0;; set++)
85	✗✗✗✓ ✓✗✓	5953	switch(set->cmd) {
86			/*
87			* When copying the user, group or other bits around, we "know"
88			* where the bits are in the mode so that we can do shifts to
89			* copy them around. If we don't use shifts, it gets real
90			* grundgy with lots of single bit checks and bit sets.
91			*/
92			case 'u':
93			value = (newmode & S_IRWXU) >> 6;
94			goto common;
95
96			case 'g':
97			value = (newmode & S_IRWXG) >> 3;
98			goto common;
99
100			case 'o':
101			value = newmode & S_IRWXO;
102			common: if (set->cmd2 & CMD2_CLR) {
103			clrval =
104			(set->cmd2 & CMD2_SET) ? S_IRWXO : value;
105			if (set->cmd2 & CMD2_UBITS)
106			newmode &= ~((clrval<<6) & set->bits);
107			if (set->cmd2 & CMD2_GBITS)
108			newmode &= ~((clrval<<3) & set->bits);
109			if (set->cmd2 & CMD2_OBITS)
110			newmode &= ~(clrval & set->bits);
111			}
112			if (set->cmd2 & CMD2_SET) {
113			if (set->cmd2 & CMD2_UBITS)
114			newmode \|= (value<<6) & set->bits;
115			if (set->cmd2 & CMD2_GBITS)
116			newmode \|= (value<<3) & set->bits;
117			if (set->cmd2 & CMD2_OBITS)
118			newmode \|= value & set->bits;
119			}
120			break;
121
122			case '+':
123		1950	newmode \|= set->bits;
124		1950	break;
125
126			case '-':
127		1973	newmode &= ~set->bits;
128		1973	break;
129
130			case 'X':
131			if (omode & (S_IFDIR\|S_IXUSR\|S_IXGRP\|S_IXOTH))
132			newmode \|= set->bits;
133			break;
134
135			case '\0':
136			default:
137			#ifdef SETMODE_DEBUG
138			(void)printf("getmode:%04o -> %04o\n", omode, newmode);
139			#endif
140		2030	return (newmode);
141			}
142			}
143
144			#define ADDCMD(a, b, c, d) \
145			if (set >= endset) { \
146			BITCMD *newset; \
147			setlen += SET_LEN_INCR; \
148			newset = reallocarray(saveset, setlen, sizeof(BITCMD)); \
149			if (newset == NULL) { \
150			free(saveset); \
151			return (NULL); \
152			} \
153			set = newset + (set - saveset); \
154			saveset = newset; \
155			endset = newset + (setlen - 2); \
156			} \
157			set = addcmd(set, (a), (b), (c), (d))
158
159			#define STANDARD_BITS (S_ISUID\|S_ISGID\|S_IRWXU\|S_IRWXG\|S_IRWXO)
160
161			void *
162			setmode(const char *p)
163			{
164		390	char op, *ep;
165			BITCMD set, saveset, *endset;
166		195	sigset_t sigset, sigoset;
167			mode_t mask, perm, permXbits, who;
168			int equalopdone, setlen;
169			u_long perml;
170
171	✗✓	195	if (!*p) {
172			errno = EINVAL;
173			return (NULL);
174			}
175
176			/*
177			* Get a copy of the mask for the permissions that are mask relative.
178			* Flip the bits, we want what's not set. Since it's possible that
179			* the caller is opening files inside a signal handler, protect them
180			* as best we can.
181			*/
182		195	sigfillset(&sigset);
183		195	(void)sigprocmask(SIG_BLOCK, &sigset, &sigoset);
184		195	(void)umask(mask = umask(0));
185		195	mask = ~mask;
186		195	(void)sigprocmask(SIG_SETMASK, &sigoset, NULL);
187
188			setlen = SET_LEN + 2;
189
190	✗✓	195	if ((set = calloc((u_int)sizeof(BITCMD), setlen)) == NULL)
191			return (NULL);
192			saveset = set;
193		195	endset = set + (setlen - 2);
194
195			/*
196			* If an absolute number, get it and return; disallow non-octal digits
197			* or illegal bits.
198			*/
199	✓✓	195	if (isdigit((unsigned char)*p)) {
200		12	perml = strtoul(p, &ep, 8);
201			/* The test on perml will also catch overflow. */
202	✓✗✗✓	24	if (*ep != '\0' \|\| (perml & ~(STANDARD_BITS\|S_ISTXT))) {
203			free(saveset);
204			errno = ERANGE;
205			return (NULL);
206			}
207		12	perm = (mode_t)perml;
208	✗✓✗✗ ✗✗	24	ADDCMD('=', (STANDARD_BITS\|S_ISTXT), perm, mask);
209		12	set->cmd = 0;
210		12	return (saveset);
211			}
212
213			/*
214			* Build list of structures to set/clear/copy bits as described by
215			* each clause of the symbolic mode.
216			*/
217		33	for (;;) {
218			/* First, find out which bits might be modified. */
219		536	for (who = 0;; ++p) {
220	✓✓✓✓ ✓	536	switch (*p) {
221			case 'a':
222		45	who \|= STANDARD_BITS;
223		45	break;
224			case 'u':
225		37	who \|= S_ISUID\|S_IRWXU;
226		37	break;
227			case 'g':
228		119	who \|= S_ISGID\|S_IRWXG;
229		119	break;
230			case 'o':
231		119	who \|= S_IRWXO;
232		119	break;
233			default:
234			goto getop;
235			}
236			}
237
238	✓✓✓✓ ✓✓	454	getop: if ((op = *p++) != '+' && op != '-' && op != '=') {
239		11	free(saveset);
240		11	errno = EINVAL;
241		11	return (NULL);
242			}
243	✓✓	205	if (op == '=')
244		68	equalopdone = 0;
245
246		205	who &= ~S_ISTXT;
247		563	for (perm = 0, permXbits = 0;; ++p) {
248	✓✗✗✓ ✗✓✗✗ ✗✓	563	switch (*p) {
249			case 'r':
250		197	perm \|= S_IRUSR\|S_IRGRP\|S_IROTH;
251		197	break;
252			case 's':
253			/*
254			* If specific bits where requested and
255			* only "other" bits ignore set-id.
256			*/
257			if (who == 0 \|\| (who & ~S_IRWXO))
258			perm \|= S_ISUID\|S_ISGID;
259			break;
260			case 't':
261			/*
262			* If specific bits where requested and
263			* only "other" bits ignore sticky.
264			*/
265			if (who == 0 \|\| (who & ~S_IRWXO)) {
266			who \|= S_ISTXT;
267			perm \|= S_ISTXT;
268			}
269			break;
270			case 'w':
271		70	perm \|= S_IWUSR\|S_IWGRP\|S_IWOTH;
272		70	break;
273			case 'X':
274			permXbits = S_IXUSR\|S_IXGRP\|S_IXOTH;
275			break;
276			case 'x':
277		91	perm \|= S_IXUSR\|S_IXGRP\|S_IXOTH;
278		91	break;
279			case 'u':
280			case 'g':
281			case 'o':
282			/*
283			* When ever we hit 'u', 'g', or 'o', we have
284			* to flush out any partial mode that we have,
285			* and then do the copying of the mode bits.
286			*/
287			if (perm) {
288			ADDCMD(op, who, perm, mask);
289			perm = 0;
290			}
291			if (op == '=')
292			equalopdone = 1;
293			if (op == '+' && permXbits) {
294			ADDCMD('X', who, permXbits, mask);
295			permXbits = 0;
296			}
297			ADDCMD(*p, who, op, mask);
298			break;
299
300			default:
301			/*
302			* Add any permissions that we haven't already
303			* done.
304			*/
305	✗✓✗✗	205	if (perm \|\| (op == '=' && !equalopdone)) {
306	✓✓	205	if (op == '=')
307		68	equalopdone = 1;
308	✗✓✗✗ ✗✗	410	ADDCMD(op, who, perm, mask);
309			perm = 0;
310		205	}
311	✗✓	205	if (permXbits) {
312			ADDCMD('X', who, permXbits, mask);
313			permXbits = 0;
314			}
315			goto apply;
316			}
317			}
318
319	✓✓	205	apply: if (!*p)
320			break;
321	✗✓	33	if (*p != ',')
322			goto getop;
323		33	++p;
324			}
325		172	set->cmd = 0;
326			#ifdef SETMODE_DEBUG
327			(void)printf("Before compress_mode()\n");
328			dumpmode(saveset);
329			#endif
330		172	compress_mode(saveset);
331			#ifdef SETMODE_DEBUG
332			(void)printf("After compress_mode()\n");
333			dumpmode(saveset);
334			#endif
335		172	return (saveset);
336		195	}
337
338			static BITCMD *
339			addcmd(BITCMD *set, int op, int who, int oparg, u_int mask)
340			{
341	✓✗✗✓ ✗✗✗✓	731	switch (op) {
342			case '=':
343		80	set->cmd = '-';
344		80	set->bits = who ? who : STANDARD_BITS;
345		80	set++;
346
347		80	op = '+';
348			/* FALLTHROUGH */
349			case '+':
350			case '-':
351			case 'X':
352		217	set->cmd = op;
353		217	set->bits = (who ? who : mask) & oparg;
354		217	break;
355
356			case 'u':
357			case 'g':
358			case 'o':
359			set->cmd = op;
360			if (who) {
361			set->cmd2 = ((who & S_IRUSR) ? CMD2_UBITS : 0) \|
362			((who & S_IRGRP) ? CMD2_GBITS : 0) \|
363			((who & S_IROTH) ? CMD2_OBITS : 0);
364			set->bits = (mode_t)~0;
365			} else {
366			set->cmd2 = CMD2_UBITS \| CMD2_GBITS \| CMD2_OBITS;
367			set->bits = mask;
368			}
369
370			if (oparg == '+')
371			set->cmd2 \|= CMD2_SET;
372			else if (oparg == '-')
373			set->cmd2 \|= CMD2_CLR;
374			else if (oparg == '=')
375			set->cmd2 \|= CMD2_SET\|CMD2_CLR;
376			break;
377			}
378		217	return (set + 1);
379			}
380
381			#ifdef SETMODE_DEBUG
382			static void
383			dumpmode(BITCMD *set)
384			{
385			for (; set->cmd; ++set)
386			(void)printf("cmd: '%c' bits %04o%s%s%s%s%s%s\n",
387			set->cmd, set->bits, set->cmd2 ? " cmd2:" : "",
388			set->cmd2 & CMD2_CLR ? " CLR" : "",
389			set->cmd2 & CMD2_SET ? " SET" : "",
390			set->cmd2 & CMD2_UBITS ? " UBITS" : "",
391			set->cmd2 & CMD2_GBITS ? " GBITS" : "",
392			set->cmd2 & CMD2_OBITS ? " OBITS" : "");
393			}
394			#endif
395
396			/*
397			* Given an array of bitcmd structures, compress by compacting consecutive
398			* '+', '-' and 'X' commands into at most 3 commands, one of each. The 'u',
399			* 'g' and 'o' commands continue to be separate. They could probably be
400			* compacted, but it's not worth the effort.
401			*/
402			static void
403			compress_mode(BITCMD *set)
404			{
405			BITCMD *nset;
406			int setbits, clrbits, Xbits, op;
407
408		344	for (nset = set;;) {
409			/* Copy over any 'u', 'g' and 'o' commands. */
410	✓✓	688	while ((op = nset->cmd) != '+' && op != '-' && op != 'X') {
411		172	set++ = nset++;
412	✗✓	172	if (!op)
413			return;
414			}
415
416		445	for (setbits = clrbits = Xbits = 0;; nset++) {
417	✓✓	445	if ((op = nset->cmd) == '-') {
418		148	clrbits \|= nset->bits;
419		148	setbits &= ~nset->bits;
420		148	Xbits &= ~nset->bits;
421	✓✓	445	} else if (op == '+') {
422		125	setbits \|= nset->bits;
423		125	clrbits &= ~nset->bits;
424		125	Xbits &= ~nset->bits;
425	✗✓	297	} else if (op == 'X')
426			Xbits \|= nset->bits & ~setbits;
427			else
428			break;
429			}
430	✓✓	172	if (clrbits) {
431		115	set->cmd = '-';
432		115	set->cmd2 = 0;
433		115	set->bits = clrbits;
434		115	set++;
435		115	}
436	✓✓	172	if (setbits) {
437		92	set->cmd = '+';
438		92	set->cmd2 = 0;
439		92	set->bits = setbits;
440		92	set++;
441		92	}
442	✓✗	172	if (Xbits) {
443			set->cmd = 'X';
444			set->cmd2 = 0;
445			set->bits = Xbits;
446			set++;
447			}
448			}
449		172	}