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