acl_support_nfs4.c revision 290893 
1/*-
2 * Copyright (c) 2008, 2009 Edward Tomasz Napiera��a <trasz@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: stable/10/lib/libc/posix1e/acl_support_nfs4.c 290893 2015-11-15 23:54:34Z ngie $");
29
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33#include <assert.h>
34#include <err.h>
35#include <sys/acl.h>
36#include "acl_support.h"
37
38struct flagnames_struct {
39	uint32_t	flag;
40	const char	*name;
41	char		letter;
42};
43
44struct flagnames_struct a_flags[] =
45    {{ ACL_ENTRY_FILE_INHERIT, "file_inherit", 'f'},
46     { ACL_ENTRY_DIRECTORY_INHERIT, "dir_inherit", 'd'},
47     { ACL_ENTRY_INHERIT_ONLY, "inherit_only", 'i'},
48     { ACL_ENTRY_NO_PROPAGATE_INHERIT, "no_propagate", 'n'},
49     { ACL_ENTRY_SUCCESSFUL_ACCESS, "successfull_access", 'S'},
50     { ACL_ENTRY_FAILED_ACCESS, "failed_access", 'F'},
51     { ACL_ENTRY_INHERITED, "inherited", 'I' },
52     /*
53      * There is no ACE_IDENTIFIER_GROUP here - SunOS does not show it
54      * in the "flags" field.  There is no ACE_OWNER, ACE_GROUP or
55      * ACE_EVERYONE either, for obvious reasons.
56      */
57     { 0, 0, 0}};
58
59struct flagnames_struct a_access_masks[] =
60    {{ ACL_READ_DATA, "read_data", 'r'},
61     { ACL_WRITE_DATA, "write_data", 'w'},
62     { ACL_EXECUTE, "execute", 'x'},
63     { ACL_APPEND_DATA, "append_data", 'p'},
64     { ACL_DELETE_CHILD, "delete_child", 'D'},
65     { ACL_DELETE, "delete", 'd'},
66     { ACL_READ_ATTRIBUTES, "read_attributes", 'a'},
67     { ACL_WRITE_ATTRIBUTES, "write_attributes", 'A'},
68     { ACL_READ_NAMED_ATTRS, "read_xattr", 'R'},
69     { ACL_WRITE_NAMED_ATTRS, "write_xattr", 'W'},
70     { ACL_READ_ACL, "read_acl", 'c'},
71     { ACL_WRITE_ACL, "write_acl", 'C'},
72     { ACL_WRITE_OWNER, "write_owner", 'o'},
73     { ACL_SYNCHRONIZE, "synchronize", 's'},
74     { ACL_FULL_SET, "full_set", '\0'},
75     { ACL_MODIFY_SET, "modify_set", '\0'},
76     { ACL_READ_SET, "read_set", '\0'},
77     { ACL_WRITE_SET, "write_set", '\0'},
78     { 0, 0, 0}};
79
80static const char *
81format_flag(uint32_t *var, const struct flagnames_struct *flags)
82{
83
84	for (; flags->name != 0; flags++) {
85		if ((flags->flag & *var) == 0)
86			continue;
87
88		*var &= ~flags->flag;
89		return (flags->name);
90	}
91
92	return (NULL);
93}
94
95static int
96format_flags_verbose(char *str, size_t size, uint32_t var,
97    const struct flagnames_struct *flags)
98{
99	size_t off = 0;
100	const char *tmp;
101
102	while ((tmp = format_flag(&var, flags)) != NULL) {
103		off += snprintf(str + off, size - off, "%s/", tmp);
104		assert (off < size);
105	}
106
107	/* If there were any flags added... */
108	if (off > 0) {
109		off--;
110		/* ... then remove the last slash. */
111		assert(str[off] == '/');
112	}
113
114	str[off] = '\0';
115
116	return (0);
117}
118
119static int
120format_flags_compact(char *str, size_t size, uint32_t var,
121    const struct flagnames_struct *flags)
122{
123	size_t i;
124
125	for (i = 0; flags[i].letter != '\0'; i++) {
126		assert(i < size);
127		if ((flags[i].flag & var) == 0)
128			str[i] = '-';
129		else
130			str[i] = flags[i].letter;
131	}
132
133	str[i] = '\0';
134
135	return (0);
136}
137
138static int
139parse_flags_verbose(const char *strp, uint32_t *var,
140    const struct flagnames_struct *flags, const char *flags_name,
141    int *try_compact)
142{
143	int i, found, ever_found = 0;
144	char *str, *flag;
145
146	str = strdup(strp);
147	*try_compact = 0;
148	*var = 0;
149
150	while (str != NULL) {
151		flag = strsep(&str, "/:");
152
153		found = 0;
154		for (i = 0; flags[i].name != NULL; i++) {
155			if (strcmp(flags[i].name, flag) == 0) {
156				*var |= flags[i].flag;
157				found = 1;
158				ever_found = 1;
159			}
160		}
161
162		if (!found) {
163			if (ever_found)
164				warnx("malformed ACL: \"%s\" field contains "
165				    "invalid flag \"%s\"", flags_name, flag);
166			else
167				*try_compact = 1;
168			free(str);
169			return (-1);
170		}
171	}
172
173	free(str);
174	return (0);
175}
176
177static int
178parse_flags_compact(const char *str, uint32_t *var,
179    const struct flagnames_struct *flags, const char *flags_name)
180{
181	int i, j, found;
182
183	*var = 0;
184
185	for (i = 0;; i++) {
186		if (str[i] == '\0')
187			return (0);
188
189		/* Ignore minus signs. */
190		if (str[i] == '-')
191			continue;
192
193		found = 0;
194
195		for (j = 0; flags[j].name != NULL; j++) {
196			if (flags[j].letter == str[i]) {
197				*var |= flags[j].flag;
198				found = 1;
199				break;
200			}
201		}
202
203		if (!found) {
204			warnx("malformed ACL: \"%s\" field contains "
205			    "invalid flag \"%c\"", flags_name, str[i]);
206			return (-1);
207		}
208	}
209}
210
211int
212_nfs4_format_flags(char *str, size_t size, acl_flag_t var, int verbose)
213{
214
215	if (verbose)
216		return (format_flags_verbose(str, size, var, a_flags));
217
218	return (format_flags_compact(str, size, var, a_flags));
219}
220
221int
222_nfs4_format_access_mask(char *str, size_t size, acl_perm_t var, int verbose)
223{
224
225	if (verbose)
226		return (format_flags_verbose(str, size, var, a_access_masks));
227
228	return (format_flags_compact(str, size, var, a_access_masks));
229}
230
231int
232_nfs4_parse_flags(const char *str, acl_flag_t *flags)
233{
234	int error, try_compact;
235	int tmpflags;
236
237	error = parse_flags_verbose(str, &tmpflags, a_flags, "flags", &try_compact);
238	if (error && try_compact)
239		error = parse_flags_compact(str, &tmpflags, a_flags, "flags");
240
241	*flags = tmpflags;
242
243	return (error);
244}
245
246int
247_nfs4_parse_access_mask(const char *str, acl_perm_t *perms)
248{
249	int error, try_compact;
250	int tmpperms;
251
252	error = parse_flags_verbose(str, &tmpperms, a_access_masks,
253	    "access permissions", &try_compact);
254	if (error && try_compact)
255		error = parse_flags_compact(str, &tmpperms,
256		    a_access_masks, "access permissions");
257
258	*perms = tmpperms;
259
260	return (error);
261}
262