[apple/libc.git] / gen / filesec.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <sys/types.h>
#include <sys/acl.h>
#include <stdlib.h>
#include <fcntl.h>
#include <strings.h>
#include <errno.h>
#include <uuid/uuid.h>


struct _filesec {
	int	fs_valid;
#define FS_VALID_UID		(1<<0)
#define FS_VALID_GID		(1<<1)
#define FS_VALID_UUID		(1<<2)
#define FS_VALID_GRPUUID	(1<<3)
#define	FS_VALID_MODE		(1<<4)
#define FS_VALID_ACL		(1<<5)
	uid_t	fs_uid;
	gid_t	fs_gid;
	uuid_t	fs_uuid;
	uuid_t	fs_grpuuid;
	mode_t	fs_mode;
	size_t	fs_aclsize;
	void	*fs_aclbuf;
};

#define FS_ISVALID(_fsec, _bit)	((_fsec)->fs_valid & (_bit))
#define FS_CLEAR(_fsec, _bit)	((_fsec)->fs_valid &= ~(_bit))
#define FS_SET(_fsec, _bit)	((_fsec)->fs_valid |= (_bit))

static void	filesec_discard_aclbuf(struct _filesec *fsec);

filesec_t
filesec_init(void)
{
	struct _filesec	*fsp;

	fsp = malloc(sizeof(*fsp));
	if (fsp != NULL)
		fsp->fs_valid = 0;
	return(fsp);
}

filesec_t
filesec_dup(filesec_t fsec)
{
	struct _filesec *fsp;

	fsp = malloc(sizeof(*fsp));
	if (fsp != NULL) {
		*fsp = *fsec;
		if (FS_ISVALID(fsec, FS_VALID_ACL)) {
			if (fsec->fs_aclbuf != _FILESEC_REMOVE_ACL) {
				fsp->fs_aclbuf = malloc(fsec->fs_aclsize);
				if (fsp->fs_aclbuf == NULL) {
					free(fsp);
					return(NULL);
				}
				bcopy(fsec->fs_aclbuf, fsp->fs_aclbuf, fsec->fs_aclsize);
			}
		}
	}
	return(fsp);
}

void
filesec_free(filesec_t fsec)
{
	filesec_discard_aclbuf(fsec);
	free(fsec);
}

int
filesec_get_property(filesec_t fsec, filesec_property_t property, void *propptr)
{
	int		error;

	error = 0;
	switch(property) {
	case FILESEC_OWNER:
		if (!FS_ISVALID(fsec, FS_VALID_UID)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			*(uid_t *)propptr = fsec->fs_uid;
		break;
	case FILESEC_GROUP:
		if (!FS_ISVALID(fsec, FS_VALID_GID)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			*(gid_t *)propptr = fsec->fs_gid;
		break;
	case FILESEC_UUID:
		if (!FS_ISVALID(fsec, FS_VALID_UUID)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			uuid_copy(*(uuid_t *)propptr, fsec->fs_uuid);
		break;
	case FILESEC_GRPUUID:
		if (!FS_ISVALID(fsec, FS_VALID_GRPUUID)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			uuid_copy(*(uuid_t *)propptr, fsec->fs_grpuuid);
		break;
	case FILESEC_MODE:
		if (!FS_ISVALID(fsec, FS_VALID_MODE)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			*(mode_t *)propptr = fsec->fs_mode;
		break;
	case FILESEC_ACL:
		if (!FS_ISVALID(fsec, FS_VALID_ACL)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL) {
			if (fsec->fs_aclbuf == _FILESEC_REMOVE_ACL) {
				*(acl_t *)propptr = _FILESEC_REMOVE_ACL;
			} else {
				*(acl_t *)propptr = acl_copy_int(fsec->fs_aclbuf);
				if (*(acl_t *)propptr == NULL)
					error = errno;
			}
		}
		break;
	case FILESEC_ACL_RAW:
		if (!FS_ISVALID(fsec, FS_VALID_ACL)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			*(void **)propptr = fsec->fs_aclbuf;
		break;
	case FILESEC_ACL_ALLOCSIZE:
		if (!FS_ISVALID(fsec, FS_VALID_ACL)) {
			error = ENOENT;
			break;
		}
		if (propptr != NULL)
			*(size_t *)propptr = fsec->fs_aclsize;
		break;
	default:
		error = EINVAL;
		break;
	}
	if (error) {
		errno = error;
		return(-1);
	}
	return(0);
}

int
filesec_set_property(filesec_t fsec, filesec_property_t property, const void *propptr)
{
	void	*aclbuf;
	ssize_t	aclsize, copysize;
	acl_t	acl;
	int	error;

	error = 0;
	switch(property) {
	case FILESEC_OWNER:
		if (propptr == _FILESEC_UNSET_PROPERTY) {
			FS_CLEAR(fsec, FS_VALID_UID);
		} else {
			fsec->fs_uid = *(uid_t *)propptr;
			FS_SET(fsec, FS_VALID_UID);
		}
		break;
	case FILESEC_GROUP:
		if (propptr == _FILESEC_UNSET_PROPERTY) {
			FS_CLEAR(fsec, FS_VALID_GID);
		} else {
			fsec->fs_gid = *(gid_t *)propptr;
			FS_SET(fsec, FS_VALID_GID);
		}
		break;
	case FILESEC_UUID:
		if (propptr == _FILESEC_UNSET_PROPERTY) {
			FS_CLEAR(fsec, FS_VALID_UUID);
		} else {
			uuid_copy(fsec->fs_uuid, *(uuid_t *)propptr);
			FS_SET(fsec, FS_VALID_UUID);
		}
		break;
	case FILESEC_GRPUUID:
		if (propptr == _FILESEC_UNSET_PROPERTY) {
			FS_CLEAR(fsec, FS_VALID_GRPUUID);
		} else {
			uuid_copy(fsec->fs_grpuuid, *(uuid_t *)propptr);
			FS_SET(fsec, FS_VALID_GRPUUID);
		}
		break;
	case FILESEC_MODE:
		if (propptr == _FILESEC_UNSET_PROPERTY) {
			FS_CLEAR(fsec, FS_VALID_MODE);
		} else {
			fsec->fs_mode = *(mode_t *)propptr;
			FS_SET(fsec, FS_VALID_MODE);
		}
		break;
	case FILESEC_ACL:
		if (propptr == _FILESEC_UNSET_PROPERTY) {
			filesec_discard_aclbuf(fsec);
			FS_CLEAR(fsec, FS_VALID_ACL);
		} else if (propptr == _FILESEC_REMOVE_ACL) {
			filesec_discard_aclbuf(fsec);
			fsec->fs_aclbuf = _FILESEC_REMOVE_ACL;
			fsec->fs_aclsize = 0;
			FS_SET(fsec, FS_VALID_ACL);
		} else {
			acl = *(acl_t *)propptr;
			aclsize = acl_size(acl);
			if (aclsize < 0) {
				error = errno;
				break;
			}
			if ((aclbuf = malloc(aclsize)) == NULL) {
				error = errno;
				break;
			}
			copysize = acl_copy_ext(aclbuf, acl, aclsize);
			if (copysize < 0) {
				free(aclbuf);
				error = EINVAL;
				break;
			}
			filesec_discard_aclbuf(fsec);
			fsec->fs_aclbuf = aclbuf;
			fsec->fs_aclsize = aclsize;
			FS_SET(fsec, FS_VALID_ACL);
		}
		break;
	case FILESEC_ACL_RAW:
		filesec_discard_aclbuf(fsec);
		if ((propptr != NULL) && (*(void **)propptr != NULL)) {
			fsec->fs_aclbuf = *(void **)propptr;
			FS_SET(fsec, FS_VALID_ACL);
		}
		break;
	case FILESEC_ACL_ALLOCSIZE:
		if (propptr != NULL) {
			fsec->fs_aclsize = *(size_t *)propptr;
		} else {
			error = EINVAL;
		}
		break;
	default:
		error = EINVAL;
		break;
	}
	if (error != 0) {
		errno = error;
		return (-1);
	}
	return (0);
}

int
filesec_query_property(filesec_t fsec, filesec_property_t property, int *validptr)
{
	int	valid, error;

	error = 0;
	switch(property) {
	case FILESEC_OWNER:
		valid = FS_ISVALID(fsec, FS_VALID_UID);
		break;
	case FILESEC_GROUP:
		valid = FS_ISVALID(fsec, FS_VALID_GID);
		break;
	case FILESEC_UUID:
		valid = FS_ISVALID(fsec, FS_VALID_UUID);
		break;
	case FILESEC_GRPUUID:
		valid = FS_ISVALID(fsec, FS_VALID_GRPUUID);
		break;
	case FILESEC_MODE:
		valid = FS_ISVALID(fsec, FS_VALID_MODE);
		break;
	case FILESEC_ACL:
	case FILESEC_ACL_RAW:
	case FILESEC_ACL_ALLOCSIZE:
		valid = FS_ISVALID(fsec, FS_VALID_ACL);
		break;
	default:
		error = EINVAL;
		break;
	}

	if (error != 0) {
		errno = error;
		return(-1);
	}
	*validptr = valid;
	return(0);
}

static void
filesec_discard_aclbuf(struct _filesec *fsec)
{
	if (FS_ISVALID(fsec, FS_VALID_ACL)) {
		if (fsec->fs_aclbuf != _FILESEC_REMOVE_ACL)
			free(fsec->fs_aclbuf);
		fsec->fs_aclbuf = NULL;
		fsec->fs_aclsize = 0;
		FS_CLEAR(fsec, FS_VALID_ACL);
	}
}
Commit	Line	Data
3d9156a7 A	1	/*
	2	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24	#include <sys/types.h>
	25	#include <sys/acl.h>
	26	#include <stdlib.h>
	27	#include <fcntl.h>
	28	#include <strings.h>
	29	#include <errno.h>
	30	#include <uuid/uuid.h>
	31
	32
	33	struct _filesec {
	34	int fs_valid;
	35	#define FS_VALID_UID (1<<0)
	36	#define FS_VALID_GID (1<<1)
	37	#define FS_VALID_UUID (1<<2)
	38	#define FS_VALID_GRPUUID (1<<3)
	39	#define FS_VALID_MODE (1<<4)
	40	#define FS_VALID_ACL (1<<5)
	41	uid_t fs_uid;
	42	gid_t fs_gid;
	43	uuid_t fs_uuid;
	44	uuid_t fs_grpuuid;
	45	mode_t fs_mode;
	46	size_t fs_aclsize;
	47	void *fs_aclbuf;
	48	};
	49
	50	#define FS_ISVALID(_fsec, _bit) ((_fsec)->fs_valid & (_bit))
	51	#define FS_CLEAR(_fsec, _bit) ((_fsec)->fs_valid &= ~(_bit))
	52	#define FS_SET(_fsec, _bit) ((_fsec)->fs_valid \|= (_bit))
	53
	54	static void filesec_discard_aclbuf(struct _filesec *fsec);
	55
	56	filesec_t
	57	filesec_init(void)
	58	{
	59	struct _filesec *fsp;
	60
	61	fsp = malloc(sizeof(*fsp));
	62	if (fsp != NULL)
	63	fsp->fs_valid = 0;
	64	return(fsp);
65	}
66
67	filesec_t
68	filesec_dup(filesec_t fsec)
69	{
70	struct _filesec *fsp;
71
72	fsp = malloc(sizeof(*fsp));
73	if (fsp != NULL) {
74	fsp = fsec;
75	if (FS_ISVALID(fsec, FS_VALID_ACL)) {
76	if (fsec->fs_aclbuf != _FILESEC_REMOVE_ACL) {
77	fsp->fs_aclbuf = malloc(fsec->fs_aclsize);
78	if (fsp->fs_aclbuf == NULL) {
79	free(fsp);
80	return(NULL);
81	}
82	bcopy(fsec->fs_aclbuf, fsp->fs_aclbuf, fsec->fs_aclsize);
83	}
84	}
85	}
86	return(fsp);
87	}
88
89	void
90	filesec_free(filesec_t fsec)
91	{
92	filesec_discard_aclbuf(fsec);
93	free(fsec);
94	}
95
96	int
97	filesec_get_property(filesec_t fsec, filesec_property_t property, void *propptr)
98	{
99	int error;
100
101	error = 0;
102	switch(property) {
103	case FILESEC_OWNER:
104	if (!FS_ISVALID(fsec, FS_VALID_UID)) {
105	error = ENOENT;
106	break;
107	}
108	if (propptr != NULL)
109	(uid_t )propptr = fsec->fs_uid;
110	break;
111	case FILESEC_GROUP:
112	if (!FS_ISVALID(fsec, FS_VALID_GID)) {
113	error = ENOENT;
114	break;
115	}
116	if (propptr != NULL)
117	(gid_t )propptr = fsec->fs_gid;
118	break;
119	case FILESEC_UUID:
120	if (!FS_ISVALID(fsec, FS_VALID_UUID)) {
121	error = ENOENT;
122	break;
123	}
124	if (propptr != NULL)
125	uuid_copy((uuid_t )propptr, fsec->fs_uuid);
126	break;
127	case FILESEC_GRPUUID:
128	if (!FS_ISVALID(fsec, FS_VALID_GRPUUID)) {
129	error = ENOENT;
130	break;
131	}
132	if (propptr != NULL)
133	uuid_copy((uuid_t )propptr, fsec->fs_grpuuid);
134	break;
135	case FILESEC_MODE:
136	if (!FS_ISVALID(fsec, FS_VALID_MODE)) {
137	error = ENOENT;
138	break;
139	}
140	if (propptr != NULL)
141	(mode_t )propptr = fsec->fs_mode;
142	break;
143	case FILESEC_ACL:
144	if (!FS_ISVALID(fsec, FS_VALID_ACL)) {
145	error = ENOENT;
146	break;
147	}
148	if (propptr != NULL) {
149	if (fsec->fs_aclbuf == _FILESEC_REMOVE_ACL) {
150	(acl_t )propptr = _FILESEC_REMOVE_ACL;
151	} else {
152	(acl_t )propptr = acl_copy_int(fsec->fs_aclbuf);
153	if ((acl_t )propptr == NULL)
154	error = errno;
155	}
156	}
157	break;
158	case FILESEC_ACL_RAW:
159	if (!FS_ISVALID(fsec, FS_VALID_ACL)) {
160	error = ENOENT;
161	break;
162	}
163	if (propptr != NULL)
164	(void *)propptr = fsec->fs_aclbuf;
165	break;
166	case FILESEC_ACL_ALLOCSIZE:
167	if (!FS_ISVALID(fsec, FS_VALID_ACL)) {
168	error = ENOENT;
169	break;
170	}
171	if (propptr != NULL)
172	(size_t )propptr = fsec->fs_aclsize;
173	break;
174	default:
175	error = EINVAL;
176	break;
177	}
178	if (error) {
179	errno = error;
180	return(-1);
181	}
182	return(0);
183	}
184
185	int
186	filesec_set_property(filesec_t fsec, filesec_property_t property, const void *propptr)
187	{
188	void *aclbuf;
189	ssize_t aclsize, copysize;
190	acl_t acl;
191	int error;
192
193	error = 0;
194	switch(property) {
195	case FILESEC_OWNER:
196	if (propptr == _FILESEC_UNSET_PROPERTY) {
197	FS_CLEAR(fsec, FS_VALID_UID);
198	} else {
199	fsec->fs_uid = (uid_t )propptr;
200	FS_SET(fsec, FS_VALID_UID);
201	}
202	break;
203	case FILESEC_GROUP:
204	if (propptr == _FILESEC_UNSET_PROPERTY) {
205	FS_CLEAR(fsec, FS_VALID_GID);
206	} else {
207	fsec->fs_gid = (gid_t )propptr;
208	FS_SET(fsec, FS_VALID_GID);
209	}
210	break;
211	case FILESEC_UUID:
212	if (propptr == _FILESEC_UNSET_PROPERTY) {
213	FS_CLEAR(fsec, FS_VALID_UUID);
214	} else {
215	uuid_copy(fsec->fs_uuid, (uuid_t )propptr);
216	FS_SET(fsec, FS_VALID_UUID);
217	}
218	break;
219	case FILESEC_GRPUUID:
220	if (propptr == _FILESEC_UNSET_PROPERTY) {
221	FS_CLEAR(fsec, FS_VALID_GRPUUID);
222	} else {
223	uuid_copy(fsec->fs_grpuuid, (uuid_t )propptr);
224	FS_SET(fsec, FS_VALID_GRPUUID);
225	}
226	break;
227	case FILESEC_MODE:
228	if (propptr == _FILESEC_UNSET_PROPERTY) {
229	FS_CLEAR(fsec, FS_VALID_MODE);
230	} else {
231	fsec->fs_mode = (mode_t )propptr;
232	FS_SET(fsec, FS_VALID_MODE);
233	}
234	break;
235	case FILESEC_ACL:
236	if (propptr == _FILESEC_UNSET_PROPERTY) {
237	filesec_discard_aclbuf(fsec);
238	FS_CLEAR(fsec, FS_VALID_ACL);
239	} else if (propptr == _FILESEC_REMOVE_ACL) {
240	filesec_discard_aclbuf(fsec);
241	fsec->fs_aclbuf = _FILESEC_REMOVE_ACL;
242	fsec->fs_aclsize = 0;
243	FS_SET(fsec, FS_VALID_ACL);
244	} else {
245	acl = (acl_t )propptr;
246	aclsize = acl_size(acl);
247	if (aclsize < 0) {
248	error = errno;
249	break;
250	}
251	if ((aclbuf = malloc(aclsize)) == NULL) {
252	error = errno;
253	break;
254	}
255	copysize = acl_copy_ext(aclbuf, acl, aclsize);
256	if (copysize < 0) {
257	free(aclbuf);
258	error = EINVAL;
259	break;
260	}
261	filesec_discard_aclbuf(fsec);
262	fsec->fs_aclbuf = aclbuf;
263	fsec->fs_aclsize = aclsize;
264	FS_SET(fsec, FS_VALID_ACL);
265	}
266	break;
267	case FILESEC_ACL_RAW:
268	filesec_discard_aclbuf(fsec);
269	if ((propptr != NULL) && ((void *)propptr != NULL)) {
270	fsec->fs_aclbuf = (void *)propptr;
271	FS_SET(fsec, FS_VALID_ACL);
272	}
273	break;
274	case FILESEC_ACL_ALLOCSIZE:
275	if (propptr != NULL) {
276	fsec->fs_aclsize = (size_t )propptr;
277	} else {
278	error = EINVAL;
279	}
280	break;
281	default:
282	error = EINVAL;
283	break;
284	}
285	if (error != 0) {
286	errno = error;
287	return (-1);
288	}
289	return (0);
290	}
291
292	int
293	filesec_query_property(filesec_t fsec, filesec_property_t property, int *validptr)
294	{
295	int valid, error;
296
297	error = 0;
298	switch(property) {
299	case FILESEC_OWNER:
300	valid = FS_ISVALID(fsec, FS_VALID_UID);
301	break;
302	case FILESEC_GROUP:
303	valid = FS_ISVALID(fsec, FS_VALID_GID);
304	break;
305	case FILESEC_UUID:
306	valid = FS_ISVALID(fsec, FS_VALID_UUID);
307	break;
308	case FILESEC_GRPUUID:
309	valid = FS_ISVALID(fsec, FS_VALID_GRPUUID);
310	break;
311	case FILESEC_MODE:
312	valid = FS_ISVALID(fsec, FS_VALID_MODE);
313	break;
314	case FILESEC_ACL:
315	case FILESEC_ACL_RAW:
316	case FILESEC_ACL_ALLOCSIZE:
317	valid = FS_ISVALID(fsec, FS_VALID_ACL);
318	break;
319	default:
320	error = EINVAL;
321	break;
322	}
323
324	if (error != 0) {
325	errno = error;
326	return(-1);
327	}
328	*validptr = valid;
329	return(0);
330	}
331
332	static void
333	filesec_discard_aclbuf(struct _filesec *fsec)
334	{
335	if (FS_ISVALID(fsec, FS_VALID_ACL)) {
336	if (fsec->fs_aclbuf != _FILESEC_REMOVE_ACL)
337	free(fsec->fs_aclbuf);
338	fsec->fs_aclbuf = NULL;
339	fsec->fs_aclsize = 0;
340	FS_CLEAR(fsec, FS_VALID_ACL);
341	}
342	}