/*

 * 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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#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 <sys/sa.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)

#define	ALL_MODE_EXECS (S_IXUSR | S_IXGRP | S_IXOTH)

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

};

/*

 * The following three functions are provided for compatibility with

 * older ZPL version in order to determine if the file use to have

 * an external ACL and what version of ACL previously existed on the

 * file.  Would really be nice to not need this, sigh.

 */

uint64_t

zfs_external_acl(znode_t *zp)

{

	zfs_acl_phys_t acl_phys;

	int error;

	if (zp->z_is_sa)

		return (0);

	/*

	 * Need to deal with a potential

	 * race where zfs_sa_upgrade could cause

	 * z_isa_sa to change.

	 *

	 * If the lookup fails then the state of z_is_sa should have

	 * changed.

	 */

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zp->z_zfsvfs),

	    &acl_phys, sizeof (acl_phys))) == 0)

		return (acl_phys.z_acl_extern_obj);

	else {

		/*

		 * after upgrade the SA_ZPL_ZNODE_ACL should have been

		 * removed

		 */

		VERIFY(zp->z_is_sa && error == ENOENT);

		return (0);

	}

}

/*

 * Determine size of ACL in bytes

 *

 * This is more complicated than it should be since we have to deal

 * with old external ACLs.

 */

static int

zfs_acl_znode_info(znode_t *zp, int *aclsize, int *aclcount,

    zfs_acl_phys_t *aclphys)

{

	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	uint64_t acl_count;

	int size;

	int error;

	ASSERT(MUTEX_HELD(&zp->z_acl_lock));

	if (zp->z_is_sa) {

		if ((error = sa_size(zp->z_sa_hdl, SA_ZPL_DACL_ACES(zfsvfs),

		    &size)) != 0)

			return (error);

		*aclsize = size;

		if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_DACL_COUNT(zfsvfs),

		    &acl_count, sizeof (acl_count))) != 0)

			return (error);

		*aclcount = acl_count;

	} else {

		if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zfsvfs),

		    aclphys, sizeof (*aclphys))) != 0)

			return (error);

		if (aclphys->z_acl_version == ZFS_ACL_VERSION_INITIAL) {

			*aclsize = ZFS_ACL_SIZE(aclphys->z_acl_size);

			*aclcount = aclphys->z_acl_size;

		} else {

			*aclsize = aclphys->z_acl_size;

			*aclcount = aclphys->z_acl_count;

		}

	}

	return (0);

}

int

zfs_znode_acl_version(znode_t *zp)

{

	zfs_acl_phys_t acl_phys;

	if (zp->z_is_sa)

		return (ZFS_ACL_VERSION_FUID);

	else {

		int error;

		/*

		 * Need to deal with a potential

		 * race where zfs_sa_upgrade could cause

		 * z_isa_sa to change.

		 *

		 * If the lookup fails then the state of z_is_sa should have

		 * changed.

		 */

		if ((error = sa_lookup(zp->z_sa_hdl,

		    SA_ZPL_ZNODE_ACL(zp->z_zfsvfs),

		    &acl_phys, sizeof (acl_phys))) == 0)

			return (acl_phys.z_acl_version);

		else {

			/*

			 * After upgrade SA_ZPL_ZNODE_ACL should have

			 * been removed.

			 */

			VERIFY(zp->z_is_sa && error == ENOENT);

			return (ZFS_ACL_VERSION_FUID);

		}

	}

}

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));

}

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);

}

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);