/*

 * 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 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/time.h>

#include <sys/systm.h>

#include <sys/sysmacros.h>

#include <sys/resource.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/sid.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <sys/kmem.h>

#include <sys/cmn_err.h>

#include <sys/errno.h>

#include <sys/unistd.h>

#include <sys/sdt.h>

#include <sys/fs/zfs.h>

#include <sys/mode.h>

#include <sys/policy.h>

#include <sys/zfs_znode.h>

#include <sys/zfs_fuid.h>

#include <sys/zfs_acl.h>

#include <sys/zfs_dir.h>

#include <sys/zfs_vfsops.h>

#include <sys/dmu.h>

#include <sys/dnode.h>

#include <sys/zap.h>

#include "fs/fs_subr.h"

#include <acl/acl_common.h>

#define	ALLOW	ACE_ACCESS_ALLOWED_ACE_TYPE

#define	DENY	ACE_ACCESS_DENIED_ACE_TYPE

#define	MAX_ACE_TYPE	ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE

#define	MIN_ACE_TYPE	ALLOW

#define	OWNING_GROUP		(ACE_GROUP|ACE_IDENTIFIER_GROUP)

#define	EVERYONE_ALLOW_MASK (ACE_READ_ACL|ACE_READ_ATTRIBUTES | \

    ACE_READ_NAMED_ATTRS|ACE_SYNCHRONIZE)

#define	EVERYONE_DENY_MASK (ACE_WRITE_ACL|ACE_WRITE_OWNER | \

    ACE_WRITE_ATTRIBUTES|ACE_WRITE_NAMED_ATTRS)

#define	OWNER_ALLOW_MASK (ACE_WRITE_ACL | ACE_WRITE_OWNER | \

    ACE_WRITE_ATTRIBUTES|ACE_WRITE_NAMED_ATTRS)

#define	ZFS_CHECKED_MASKS (ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_DATA| \

    ACE_READ_NAMED_ATTRS|ACE_WRITE_DATA|ACE_WRITE_ATTRIBUTES| \

    ACE_WRITE_NAMED_ATTRS|ACE_APPEND_DATA|ACE_EXECUTE|ACE_WRITE_OWNER| \

    ACE_WRITE_ACL|ACE_DELETE|ACE_DELETE_CHILD|ACE_SYNCHRONIZE)

#define	WRITE_MASK_DATA (ACE_WRITE_DATA|ACE_APPEND_DATA|ACE_WRITE_NAMED_ATTRS)

#define	WRITE_MASK_ATTRS (ACE_WRITE_ACL|ACE_WRITE_OWNER|ACE_WRITE_ATTRIBUTES| \

    ACE_DELETE|ACE_DELETE_CHILD)

#define	WRITE_MASK (WRITE_MASK_DATA|WRITE_MASK_ATTRS)

#define	OGE_CLEAR	(ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \

    ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_EXECUTE)

#define	OKAY_MASK_BITS (ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \

    ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_EXECUTE)

#define	ALL_INHERIT	(ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE | \

    ACE_NO_PROPAGATE_INHERIT_ACE|ACE_INHERIT_ONLY_ACE|ACE_INHERITED_ACE)

#define	RESTRICTED_CLEAR	(ACE_WRITE_ACL|ACE_WRITE_OWNER)

#define	V4_ACL_WIDE_FLAGS (ZFS_ACL_AUTO_INHERIT|ZFS_ACL_DEFAULTED|\

    ZFS_ACL_PROTECTED)

#define	ZFS_ACL_WIDE_FLAGS (V4_ACL_WIDE_FLAGS|ZFS_ACL_TRIVIAL|ZFS_INHERIT_ACE|\

    ZFS_ACL_OBJ_ACE)

static uint16_t

zfs_ace_v0_get_type(void *acep)

{

	return (((zfs_oldace_t *)acep)->z_type);

}

static uint16_t

zfs_ace_v0_get_flags(void *acep)

{

	return (((zfs_oldace_t *)acep)->z_flags);

}

static uint32_t

zfs_ace_v0_get_mask(void *acep)

{

	return (((zfs_oldace_t *)acep)->z_access_mask);

}

static uint64_t

zfs_ace_v0_get_who(void *acep)

{

	return (((zfs_oldace_t *)acep)->z_fuid);

}

static void

zfs_ace_v0_set_type(void *acep, uint16_t type)

{

	((zfs_oldace_t *)acep)->z_type = type;

}

static void

zfs_ace_v0_set_flags(void *acep, uint16_t flags)

{

	((zfs_oldace_t *)acep)->z_flags = flags;

}

static void

zfs_ace_v0_set_mask(void *acep, uint32_t mask)

{

	((zfs_oldace_t *)acep)->z_access_mask = mask;

}

static void

zfs_ace_v0_set_who(void *acep, uint64_t who)

{

	((zfs_oldace_t *)acep)->z_fuid = who;

}

/*ARGSUSED*/

static size_t

zfs_ace_v0_size(void *acep)

{

	return (sizeof (zfs_oldace_t));

}

static size_t

zfs_ace_v0_abstract_size(void)

{

	return (sizeof (zfs_oldace_t));

}

static int

zfs_ace_v0_mask_off(void)

{

	return (offsetof(zfs_oldace_t, z_access_mask));

}

/*ARGSUSED*/

static int

zfs_ace_v0_data(void *acep, void **datap)

{

	*datap = NULL;

	return (0);

}

static acl_ops_t zfs_acl_v0_ops = {

	zfs_ace_v0_get_mask,

	zfs_ace_v0_set_mask,

	zfs_ace_v0_get_flags,

	zfs_ace_v0_set_flags,

	zfs_ace_v0_get_type,

	zfs_ace_v0_set_type,

	zfs_ace_v0_get_who,

	zfs_ace_v0_set_who,

	zfs_ace_v0_size,

	zfs_ace_v0_abstract_size,

	zfs_ace_v0_mask_off,

	zfs_ace_v0_data

};

static uint16_t

zfs_ace_fuid_get_type(void *acep)

{

	return (((zfs_ace_hdr_t *)acep)->z_type);

}

static uint16_t

zfs_ace_fuid_get_flags(void *acep)

{

	return (((zfs_ace_hdr_t *)acep)->z_flags);

}

static uint32_t

zfs_ace_fuid_get_mask(void *acep)

{

	return (((zfs_ace_hdr_t *)acep)->z_access_mask);

}

static uint64_t

zfs_ace_fuid_get_who(void *args)

{

	uint16_t entry_type;

	zfs_ace_t *acep = args;

	entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS;

	if (entry_type == ACE_OWNER || entry_type == OWNING_GROUP ||

	    entry_type == ACE_EVERYONE)

		return (-1);

	return (((zfs_ace_t *)acep)->z_fuid);

}

static void

zfs_ace_fuid_set_type(void *acep, uint16_t type)

{

	((zfs_ace_hdr_t *)acep)->z_type = type;

}

static void

zfs_ace_fuid_set_flags(void *acep, uint16_t flags)

{

	((zfs_ace_hdr_t *)acep)->z_flags = flags;

}

static void

zfs_ace_fuid_set_mask(void *acep, uint32_t mask)

{

	((zfs_ace_hdr_t *)acep)->z_access_mask = mask;

}

static void

zfs_ace_fuid_set_who(void *arg, uint64_t who)

{

	zfs_ace_t *acep = arg;

	uint16_t entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS;

	if (entry_type == ACE_OWNER || entry_type == OWNING_GROUP ||

	    entry_type == ACE_EVERYONE)

		return;

	acep->z_fuid = who;

}

static size_t

zfs_ace_fuid_size(void *acep)

{

	zfs_ace_hdr_t *zacep = acep;

	uint16_t entry_type;

	switch (zacep->z_type) {

	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:

	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:

	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:

	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:

		return (sizeof (zfs_object_ace_t));

	case ALLOW:

	case DENY:

		entry_type =

		    (((zfs_ace_hdr_t *)acep)->z_flags & ACE_TYPE_FLAGS);

		if (entry_type == ACE_OWNER ||

		    entry_type == OWNING_GROUP ||

		    entry_type == ACE_EVERYONE)

			return (sizeof (zfs_ace_hdr_t));

		/*FALLTHROUGH*/

	default:

		return (sizeof (zfs_ace_t));

	}

}

static size_t

zfs_ace_fuid_abstract_size(void)

{

	return (sizeof (zfs_ace_hdr_t));

}

static int

zfs_ace_fuid_mask_off(void)

{

	return (offsetof(zfs_ace_hdr_t, z_access_mask));

}

static int

zfs_ace_fuid_data(void *acep, void **datap)

{

	zfs_ace_t *zacep = acep;

	zfs_object_ace_t *zobjp;

	switch (zacep->z_hdr.z_type) {

	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:

	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:

	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:

	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:

		zobjp = acep;

		*datap = (caddr_t)zobjp + sizeof (zfs_ace_t);

		return (sizeof (zfs_object_ace_t) - sizeof (zfs_ace_t));

	default:

		*datap = NULL;

		return (0);

	}

}

static acl_ops_t zfs_acl_fuid_ops = {

	zfs_ace_fuid_get_mask,

	zfs_ace_fuid_set_mask,

	zfs_ace_fuid_get_flags,

	zfs_ace_fuid_set_flags,

	zfs_ace_fuid_get_type,

	zfs_ace_fuid_set_type,

	zfs_ace_fuid_get_who,

	zfs_ace_fuid_set_who,

	zfs_ace_fuid_size,

	zfs_ace_fuid_abstract_size,

	zfs_ace_fuid_mask_off,

	zfs_ace_fuid_data

};

static int

zfs_acl_version(int version)

{

	if (version < ZPL_VERSION_FUID)

		return (ZFS_ACL_VERSION_INITIAL);

	else

		return (ZFS_ACL_VERSION_FUID);

}

static int

zfs_acl_version_zp(znode_t *zp)

{

	return (zfs_acl_version(zp->z_zfsvfs->z_version));

}

static zfs_acl_t *

zfs_acl_alloc(int vers)

{

	zfs_acl_t *aclp;

	aclp = kmem_zalloc(sizeof (zfs_acl_t), KM_SLEEP);

	list_create(&aclp->z_acl, sizeof (zfs_acl_node_t),

	    offsetof(zfs_acl_node_t, z_next));

	aclp->z_version = vers;

	if (vers == ZFS_ACL_VERSION_FUID)

		aclp->z_ops = zfs_acl_fuid_ops;

	else

		aclp->z_ops = zfs_acl_v0_ops;

	return (aclp);

}

static zfs_acl_node_t *

zfs_acl_node_alloc(size_t bytes)

{

	zfs_acl_node_t *aclnode;

	aclnode = kmem_zalloc(sizeof (zfs_acl_node_t), KM_SLEEP);

	if (bytes) {

		aclnode->z_acldata = kmem_alloc(bytes, KM_SLEEP);

		aclnode->z_allocdata = aclnode->z_acldata;

		aclnode->z_allocsize = bytes;

		aclnode->z_size = bytes;

	}

	return (aclnode);

}

static void

zfs_acl_node_free(zfs_acl_node_t *aclnode)

{

	if (aclnode->z_allocsize)

		kmem_free(aclnode->z_allocdata, aclnode->z_allocsize);

	kmem_free(aclnode, sizeof (zfs_acl_node_t));

}

static void

zfs_acl_release_nodes(zfs_acl_t *aclp)

{

	zfs_acl_node_t *aclnode;

	while (aclnode = list_head(&aclp->z_acl)) {

		list_remove(&aclp->z_acl, aclnode);

		zfs_acl_node_free(aclnode);

	}

	aclp->z_acl_count = 0;

	aclp->z_acl_bytes = 0;

}

void

zfs_acl_free(zfs_acl_t *aclp)

{

	zfs_acl_release_nodes(aclp);

	list_destroy(&aclp->z_acl);

	kmem_free(aclp, sizeof (zfs_acl_t));

}

static boolean_t

zfs_acl_valid_ace_type(uint_t type, uint_t flags)

{

	uint16_t entry_type;

	switch (type) {

	case ALLOW:

	case DENY:

	case ACE_SYSTEM_AUDIT_ACE_TYPE:

	case ACE_SYSTEM_ALARM_ACE_TYPE:

		entry_type = flags & ACE_TYPE_FLAGS;

		return (entry_type == ACE_OWNER ||

		    entry_type == OWNING_GROUP ||

		    entry_type == ACE_EVERYONE || entry_type == 0 ||

		    entry_type == ACE_IDENTIFIER_GROUP);

	default:

		if (type >= MIN_ACE_TYPE && type <= MAX_ACE_TYPE)

			return (B_TRUE);

	}

	return (B_FALSE);

}

static boolean_t

zfs_ace_valid(vtype_t obj_type, zfs_acl_t *aclp, uint16_t type, uint16_t iflags)

{

	/*

	 * first check type of entry

	 */

	if (!zfs_acl_valid_ace_type(type, iflags))

		return (B_FALSE);

	switch (type) {

	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:

	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:

	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:

	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:

		if (aclp->z_version < ZFS_ACL_VERSION_FUID)

			return (B_FALSE);

		aclp->z_hints |= ZFS_ACL_OBJ_ACE;

	}

	/*

	 * next check inheritance level flags

	 */

	if (obj_type == VDIR &&

	    (iflags & (ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE)))

		aclp->z_hints |= ZFS_INHERIT_ACE;

	if (iflags & (ACE_INHERIT_ONLY_ACE|ACE_NO_PROPAGATE_INHERIT_ACE)) {

		if ((iflags & (ACE_FILE_INHERIT_ACE|

		    ACE_DIRECTORY_INHERIT_ACE)) == 0) {

			return (B_FALSE);

		}

	}

	return (B_TRUE);

}

static void *

zfs_acl_next_ace(zfs_acl_t *aclp, void *start, uint64_t *who,

    uint32_t *access_mask, uint16_t *iflags, uint16_t *type)

{

	zfs_acl_node_t *aclnode;

	if (start == NULL) {

		aclnode = list_head(&aclp->z_acl);

		if (aclnode == NULL)

			return (NULL);

		aclp->z_next_ace = aclnode->z_acldata;

		aclp->z_curr_node = aclnode;

		aclnode->z_ace_idx = 0;

	}

	aclnode = aclp->z_curr_node;

	if (aclnode == NULL)

		return (NULL);

	if (aclnode->z_ace_idx >= aclnode->z_ace_count) {

		aclnode = list_next(&aclp->z_acl, aclnode);

		if (aclnode == NULL)

			return (NULL);

		else {

			aclp->z_curr_node = aclnode;

			aclnode->z_ace_idx = 0;

			aclp->z_next_ace = aclnode->z_acldata;

		}

	}

	if (aclnode->z_ace_idx < aclnode->z_ace_count) {

		void *acep = aclp->z_next_ace;

		size_t ace_size;

		/*

		 * Make sure we don't overstep our bounds

		 */

		ace_size = aclp->z_ops.ace_size(acep);