/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include <grp.h>

#include <pwd.h>

#include <strings.h>

#include <sys/types.h>

#include <sys/acl.h>

#include <errno.h>

#include <sys/stat.h>

#include <sys/varargs.h>

#include <locale.h>

#include <aclutils.h>

#include <acl_common.h>

#include <sys/avl.h>

#define	offsetof(s, m)	((size_t)(&(((s *)0)->m)))

#define	ACL_PATH	0

#define	ACL_FD		1

#define	ACE_POSIX_SUPPORTED_BITS (ACE_READ_DATA | \

    ACE_WRITE_DATA | ACE_APPEND_DATA | ACE_EXECUTE | \

    ACE_READ_ATTRIBUTES | ACE_READ_ACL | ACE_WRITE_ACL)

#define	ACL_SYNCHRONIZE_SET_DENY		0x0000001

#define	ACL_SYNCHRONIZE_SET_ALLOW		0x0000002

#define	ACL_SYNCHRONIZE_ERR_DENY		0x0000004

#define	ACL_SYNCHRONIZE_ERR_ALLOW		0x0000008

#define	ACL_WRITE_OWNER_SET_DENY		0x0000010

#define	ACL_WRITE_OWNER_SET_ALLOW		0x0000020

#define	ACL_WRITE_OWNER_ERR_DENY		0x0000040

#define	ACL_WRITE_OWNER_ERR_ALLOW		0x0000080

#define	ACL_DELETE_SET_DENY			0x0000100

#define	ACL_DELETE_SET_ALLOW			0x0000200

#define	ACL_DELETE_ERR_DENY			0x0000400

#define	ACL_DELETE_ERR_ALLOW			0x0000800

#define	ACL_WRITE_ATTRS_OWNER_SET_DENY		0x0001000

#define	ACL_WRITE_ATTRS_OWNER_SET_ALLOW		0x0002000

#define	ACL_WRITE_ATTRS_OWNER_ERR_DENY		0x0004000

#define	ACL_WRITE_ATTRS_OWNER_ERR_ALLOW		0x0008000

#define	ACL_WRITE_ATTRS_WRITER_SET_DENY		0x0010000

#define	ACL_WRITE_ATTRS_WRITER_SET_ALLOW	0x0020000

#define	ACL_WRITE_ATTRS_WRITER_ERR_DENY		0x0040000

#define	ACL_WRITE_ATTRS_WRITER_ERR_ALLOW	0x0080000

#define	ACL_WRITE_NAMED_WRITER_SET_DENY		0x0100000

#define	ACL_WRITE_NAMED_WRITER_SET_ALLOW	0x0200000

#define	ACL_WRITE_NAMED_WRITER_ERR_DENY		0x0400000

#define	ACL_WRITE_NAMED_WRITER_ERR_ALLOW	0x0800000

#define	ACL_READ_NAMED_READER_SET_DENY		0x1000000

#define	ACL_READ_NAMED_READER_SET_ALLOW		0x2000000

#define	ACL_READ_NAMED_READER_ERR_DENY		0x4000000

#define	ACL_READ_NAMED_READER_ERR_ALLOW		0x8000000

#define	ACE_VALID_MASK_BITS (\

    ACE_READ_DATA | \

    ACE_LIST_DIRECTORY | \

    ACE_WRITE_DATA | \

    ACE_ADD_FILE | \

    ACE_APPEND_DATA | \

    ACE_ADD_SUBDIRECTORY | \

    ACE_READ_NAMED_ATTRS | \

    ACE_WRITE_NAMED_ATTRS | \

    ACE_EXECUTE | \

    ACE_DELETE_CHILD | \

    ACE_READ_ATTRIBUTES | \

    ACE_WRITE_ATTRIBUTES | \

    ACE_DELETE | \

    ACE_READ_ACL | \

    ACE_WRITE_ACL | \

    ACE_WRITE_OWNER | \

    ACE_SYNCHRONIZE)

#define	ACE_MASK_UNDEFINED			0x80000000

#define	ACE_VALID_FLAG_BITS (ACE_FILE_INHERIT_ACE | \

    ACE_DIRECTORY_INHERIT_ACE | \

    ACE_NO_PROPAGATE_INHERIT_ACE | ACE_INHERIT_ONLY_ACE | \

    ACE_SUCCESSFUL_ACCESS_ACE_FLAG | ACE_FAILED_ACCESS_ACE_FLAG | \

    ACE_IDENTIFIER_GROUP | ACE_OWNER | ACE_GROUP | ACE_EVERYONE)

/*

 * ACL conversion helpers

 */

typedef enum {

	ace_unused,

	ace_user_obj,

	ace_user,

	ace_group, /* includes GROUP and GROUP_OBJ */

	ace_other_obj

} ace_to_aent_state_t;

typedef struct acevals {

	uid_t key;

	avl_node_t avl;

	uint32_t mask;

	uint32_t allowed;

	uint32_t denied;

	int aent_type;

} acevals_t;

typedef struct ace_list {

	acevals_t user_obj;

	avl_tree_t user;

	int numusers;

	acevals_t group_obj;

	avl_tree_t group;

	int numgroups;

	acevals_t other_obj;

	uint32_t acl_mask;

	int hasmask;

	int dfacl_flag;

	ace_to_aent_state_t state;

	int seen; /* bitmask of all aclent_t a_type values seen */

} ace_list_t;

typedef union {

	const char *file;

	int  fd;

} acl_inp;

acl_t *

acl_alloc(enum acl_type type)

{

	acl_t *aclp;

	aclp = malloc(sizeof (acl_t));

	if (aclp == NULL)

		return (NULL);

	aclp->acl_aclp = NULL;

	aclp->acl_cnt = 0;

	switch (type) {

	case ACE_T:

		aclp->acl_type = ACE_T;

		aclp->acl_entry_size = sizeof (ace_t);

		break;

	case ACLENT_T:

		aclp->acl_type = ACLENT_T;

		aclp->acl_entry_size = sizeof (aclent_t);

		break;

	default:

		acl_free(aclp);

		aclp = NULL;

	}

	return (aclp);

}

/*

 * Free acl_t structure

 */

void

acl_free(acl_t *aclp)

{

	if (aclp == NULL)

		return;

	if (aclp->acl_aclp)

		free(aclp->acl_aclp);

	free(aclp);

}

/*

 * Determine whether a file has a trivial ACL

 * returns: 	0 = trivial

 *		1 = nontrivial

 *		<0 some other system failure, such as ENOENT or EPERM

 */

int

acl_trivial(const char *filename)

{

	int acl_flavor;

	int aclcnt;

	int cntcmd;

	int val = 0;

	ace_t *acep;

	acl_flavor = pathconf(filename, _PC_ACL_ENABLED);

	if (acl_flavor == _ACL_ACE_ENABLED)

		cntcmd = ACE_GETACLCNT;

	else

		cntcmd = GETACLCNT;

	aclcnt = acl(filename, cntcmd, 0, NULL);

	if (aclcnt > 0) {

		if (acl_flavor == _ACL_ACE_ENABLED) {

			acep = malloc(sizeof (ace_t) * aclcnt);

			if (acep == NULL)

				return (-1);

			if (acl(filename, ACE_GETACL,

			    aclcnt, acep) < 0) {

				free(acep);

				return (-1);

			}

			val = ace_trivial(acep, aclcnt);

			free(acep);

		} else if (aclcnt > MIN_ACL_ENTRIES)

			val = 1;

	}

	return (val);

}

static uint32_t

access_mask_set(int haswriteperm, int hasreadperm, int isowner, int isallow)

{

	uint32_t access_mask = 0;

	int acl_produce;

	int synchronize_set = 0, write_owner_set = 0;

	int delete_set = 0, write_attrs_set = 0;

	int read_named_set = 0, write_named_set = 0;

	acl_produce = (ACL_SYNCHRONIZE_SET_ALLOW |

	    ACL_WRITE_ATTRS_OWNER_SET_ALLOW |

	    ACL_WRITE_ATTRS_WRITER_SET_DENY);

	if (isallow) {

		synchronize_set = ACL_SYNCHRONIZE_SET_ALLOW;

		write_owner_set = ACL_WRITE_OWNER_SET_ALLOW;

		delete_set = ACL_DELETE_SET_ALLOW;

		if (hasreadperm)

			read_named_set = ACL_READ_NAMED_READER_SET_ALLOW;

		if (haswriteperm)

			write_named_set = ACL_WRITE_NAMED_WRITER_SET_ALLOW;

		if (isowner)

			write_attrs_set = ACL_WRITE_ATTRS_OWNER_SET_ALLOW;

		else if (haswriteperm)

			write_attrs_set = ACL_WRITE_ATTRS_WRITER_SET_ALLOW;

	} else {

		synchronize_set = ACL_SYNCHRONIZE_SET_DENY;

		write_owner_set = ACL_WRITE_OWNER_SET_DENY;

		delete_set = ACL_DELETE_SET_DENY;

		if (hasreadperm)

			read_named_set = ACL_READ_NAMED_READER_SET_DENY;

		if (haswriteperm)

			write_named_set = ACL_WRITE_NAMED_WRITER_SET_DENY;

		if (isowner)

			write_attrs_set = ACL_WRITE_ATTRS_OWNER_SET_DENY;

		else if (haswriteperm)

			write_attrs_set = ACL_WRITE_ATTRS_WRITER_SET_DENY;

		else

			/*

			 * If the entity is not the owner and does not

			 * have write permissions ACE_WRITE_ATTRIBUTES will

			 * always go in the DENY ACE.

			 */

			access_mask |= ACE_WRITE_ATTRIBUTES;

	}

	if (acl_produce & synchronize_set)

		access_mask |= ACE_SYNCHRONIZE;

	if (acl_produce & write_owner_set)

		access_mask |= ACE_WRITE_OWNER;

	if (acl_produce & delete_set)

		access_mask |= ACE_DELETE;

	if (acl_produce & write_attrs_set)

		access_mask |= ACE_WRITE_ATTRIBUTES;

	if (acl_produce & read_named_set)

		access_mask |= ACE_READ_NAMED_ATTRS;

	if (acl_produce & write_named_set)

		access_mask |= ACE_WRITE_NAMED_ATTRS;

	return (access_mask);

}

/*

 * Given an mode_t, convert it into an access_mask as used

 * by nfsace, assuming aclent_t -> nfsace semantics.

 */

static uint32_t

mode_to_ace_access(mode_t mode, int isdir, int isowner, int isallow)

{

	uint32_t access = 0;

	int haswriteperm = 0;

	int hasreadperm = 0;

	if (isallow) {

		haswriteperm = (mode & 02);

		hasreadperm = (mode & 04);

	} else {

		haswriteperm = !(mode & 02);

		hasreadperm = !(mode & 04);

	}

	/*

	 * The following call takes care of correctly setting the following

	 * mask bits in the access_mask:

	 * ACE_SYNCHRONIZE, ACE_WRITE_OWNER, ACE_DELETE,

	 * ACE_WRITE_ATTRIBUTES, ACE_WRITE_NAMED_ATTRS, ACE_READ_NAMED_ATTRS

	 */

	access = access_mask_set(haswriteperm, hasreadperm, isowner, isallow);

	if (isallow) {

		access |= ACE_READ_ACL | ACE_READ_ATTRIBUTES;

		if (isowner)

			access |= ACE_WRITE_ACL;

	} else {

		if (! isowner)

			access |= ACE_WRITE_ACL;

	}

	/* read */

	if (mode & 04) {

		access |= ACE_READ_DATA;

	}

	/* write */

	if (mode & 02) {

		access |= ACE_WRITE_DATA |

		    ACE_APPEND_DATA;

		if (isdir)

			access |= ACE_DELETE_CHILD;

	}

	/* exec */

	if (mode & 01) {

		access |= ACE_EXECUTE;

	}

	return (access);

}

/*

 * Given an nfsace (presumably an ALLOW entry), make a

 * corresponding DENY entry at the address given.

 */

static void

ace_make_deny(ace_t *allow, ace_t *deny, int isdir, int isowner)

{

	(void) memcpy(deny, allow, sizeof (ace_t));

	deny->a_who = allow->a_who;

	deny->a_type = ACE_ACCESS_DENIED_ACE_TYPE;

	deny->a_access_mask ^= ACE_POSIX_SUPPORTED_BITS;

	if (isdir)

		deny->a_access_mask ^= ACE_DELETE_CHILD;

	deny->a_access_mask &= ~(ACE_SYNCHRONIZE | ACE_WRITE_OWNER |

	    ACE_DELETE | ACE_WRITE_ATTRIBUTES | ACE_READ_NAMED_ATTRS |

	    ACE_WRITE_NAMED_ATTRS);

	deny->a_access_mask |= access_mask_set((allow->a_access_mask &

	    ACE_WRITE_DATA), (allow->a_access_mask & ACE_READ_DATA), isowner,

	    B_FALSE);

}

/*

 * Make an initial pass over an array of aclent_t's.  Gather

 * information such as an ACL_MASK (if any), number of users,

 * number of groups, and whether the array needs to be sorted.

 */

static int

ln_aent_preprocess(aclent_t *aclent, int n,

    int *hasmask, mode_t *mask,

    int *numuser, int *numgroup, int *needsort)

{

	int error = 0;

	int i;

	int curtype = 0;

	*hasmask = 0;

	*mask = 07;

	*needsort = 0;

	*numuser = 0;

	*numgroup = 0;

	for (i = 0; i < n; i++) {

		if (aclent[i].a_type < curtype)

			*needsort = 1;

		else if (aclent[i].a_type > curtype)

			curtype = aclent[i].a_type;

		if (aclent[i].a_type & USER)

			(*numuser)++;

		if (aclent[i].a_type & (GROUP | GROUP_OBJ))

			(*numgroup)++;

		if (aclent[i].a_type & CLASS_OBJ) {

			if (*hasmask) {

				error = EINVAL;

				goto out;

			} else {

				*hasmask = 1;

				*mask = aclent[i].a_perm;

			}

		}

	}

	if ((! *hasmask) && (*numuser + *numgroup > 1)) {

		error = EINVAL;

		goto out;

	}

out:

	return (error);

}

/*

 * Convert an array of aclent_t into an array of nfsace entries,

 * following POSIX draft -> nfsv4 conversion semantics as outlined in

 * the IETF draft.

 */

static int

ln_aent_to_ace(aclent_t *aclent, int n, ace_t **acepp, int *rescount, int isdir)

{

	int error = 0;

	mode_t mask;

	int numuser, numgroup, needsort;

	int resultsize = 0;

	int i, groupi = 0, skip;

	ace_t *acep, *result = NULL;

	int hasmask;

	error = ln_aent_preprocess(aclent, n, &hasmask, &mask,

	    &numuser, &numgroup, &needsort);

	if (error != 0)

		goto out;

	/* allow + deny for each aclent */

	resultsize = n * 2;

	if (hasmask) {

		/*

		 * stick extra deny on the group_obj and on each

		 * user|group for the mask (the group_obj was added

		 * into the count for numgroup)

		 */

		resultsize += numuser + numgroup;

		/* ... and don't count the mask itself */

		resultsize -= 2;

	}

	/* sort the source if necessary */

	if (needsort)

		ksort((caddr_t)aclent, n, sizeof (aclent_t), cmp2acls);

	result = acep = calloc(1, resultsize * sizeof (ace_t));

	if (result == NULL)

		goto out;

	for (i = 0; i < n; i++) {

		/*

		 * don't process CLASS_OBJ (mask); mask was grabbed in

		 * ln_aent_preprocess()

		 */

		if (aclent[i].a_type & CLASS_OBJ)

			continue;

		/* If we need an ACL_MASK emulator, prepend it now */

		if ((hasmask) &&

		    (aclent[i].a_type & (USER | GROUP | GROUP_OBJ))) {

			acep->a_type = ACE_ACCESS_DENIED_ACE_TYPE;

			acep->a_flags = 0;

			if (aclent[i].a_type & GROUP_OBJ) {

				acep->a_who = -1;

				acep->a_flags |=

				    (ACE_IDENTIFIER_GROUP|ACE_GROUP);

			} else if (aclent[i].a_type & USER) {

				acep->a_who = aclent[i].a_id;

			} else {

				acep->a_who = aclent[i].a_id;

				acep->a_flags |= ACE_IDENTIFIER_GROUP;

			}

			if (aclent[i].a_type & ACL_DEFAULT) {

				acep->a_flags |= ACE_INHERIT_ONLY_ACE |

				    ACE_FILE_INHERIT_ACE |

				    ACE_DIRECTORY_INHERIT_ACE;

			}

			/*

			 * Set the access mask for the prepended deny

			 * ace.  To do this, we invert the mask (found

			 * in ln_aent_preprocess()) then convert it to an

			 * DENY ace access_mask.

			 */

			acep->a_access_mask = mode_to_ace_access((mask ^ 07),

			    isdir, 0, 0);

			acep += 1;

		}

		/* handle a_perm -> access_mask */

		acep->a_access_mask = mode_to_ace_access(aclent[i].a_perm,

		    isdir, aclent[i].a_type & USER_OBJ, 1);