/*

 * 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 <ctype.h>

#include <errno.h>

#include <libintl.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <unistd.h>

#include <stddef.h>

#include <zone.h>

#include <fcntl.h>

#include <sys/mntent.h>

#include <sys/mount.h>

#include <priv.h>

#include <pwd.h>

#include <grp.h>

#include <stddef.h>

#include <ucred.h>

#include <idmap.h>

#include <aclutils.h>

#include <directory.h>

#include <sys/dnode.h>

#include <sys/spa.h>

#include <sys/zap.h>

#include <libzfs.h>

#include "zfs_namecheck.h"

#include "zfs_prop.h"

#include "libzfs_impl.h"

#include "zfs_deleg.h"

static int userquota_propname_decode(const char *propname, boolean_t zoned,

    zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp);

/*

 * Given a single type (not a mask of types), return the type in a human

 * readable form.

 */

const char *

zfs_type_to_name(zfs_type_t type)

{

	switch (type) {

	case ZFS_TYPE_FILESYSTEM:

		return (dgettext(TEXT_DOMAIN, "filesystem"));

	case ZFS_TYPE_SNAPSHOT:

		return (dgettext(TEXT_DOMAIN, "snapshot"));

	case ZFS_TYPE_VOLUME:

		return (dgettext(TEXT_DOMAIN, "volume"));

	}

	return (NULL);

}

/*

 * Given a path and mask of ZFS types, return a string describing this dataset.

 * This is used when we fail to open a dataset and we cannot get an exact type.

 * We guess what the type would have been based on the path and the mask of

 * acceptable types.

 */

static const char *

path_to_str(const char *path, int types)

{

	/*

	 * When given a single type, always report the exact type.

	 */

	if (types == ZFS_TYPE_SNAPSHOT)

		return (dgettext(TEXT_DOMAIN, "snapshot"));

	if (types == ZFS_TYPE_FILESYSTEM)

		return (dgettext(TEXT_DOMAIN, "filesystem"));

	if (types == ZFS_TYPE_VOLUME)

		return (dgettext(TEXT_DOMAIN, "volume"));

	/*

	 * The user is requesting more than one type of dataset.  If this is the

	 * case, consult the path itself.  If we're looking for a snapshot, and

	 * a '@' is found, then report it as "snapshot".  Otherwise, remove the

	 * snapshot attribute and try again.

	 */

	if (types & ZFS_TYPE_SNAPSHOT) {

		if (strchr(path, '@') != NULL)

			return (dgettext(TEXT_DOMAIN, "snapshot"));

		return (path_to_str(path, types & ~ZFS_TYPE_SNAPSHOT));

	}

	/*

	 * The user has requested either filesystems or volumes.

	 * We have no way of knowing a priori what type this would be, so always

	 * report it as "filesystem" or "volume", our two primitive types.

	 */

	if (types & ZFS_TYPE_FILESYSTEM)

		return (dgettext(TEXT_DOMAIN, "filesystem"));

	assert(types & ZFS_TYPE_VOLUME);

	return (dgettext(TEXT_DOMAIN, "volume"));

}

/*

 * Validate a ZFS path.  This is used even before trying to open the dataset, to

 * provide a more meaningful error message.  We call zfs_error_aux() to

 * explain exactly why the name was not valid.

 */

static int

zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type,

    boolean_t modifying)

{

	namecheck_err_t why;

	char what;

	if (dataset_namecheck(path, &why, &what) != 0) {

		if (hdl != NULL) {

			switch (why) {

			case NAME_ERR_TOOLONG:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "name is too long"));

				break;

			case NAME_ERR_LEADING_SLASH:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "leading slash in name"));

				break;

			case NAME_ERR_EMPTY_COMPONENT:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "empty component in name"));

				break;

			case NAME_ERR_TRAILING_SLASH:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "trailing slash in name"));

				break;

			case NAME_ERR_INVALCHAR:

				zfs_error_aux(hdl,

				    dgettext(TEXT_DOMAIN, "invalid character "

				    "'%c' in name"), what);

				break;

			case NAME_ERR_MULTIPLE_AT:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "multiple '@' delimiters in name"));

				break;

			case NAME_ERR_NOLETTER:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "pool doesn't begin with a letter"));

				break;

			case NAME_ERR_RESERVED:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "name is reserved"));

				break;

			case NAME_ERR_DISKLIKE:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "reserved disk name"));

				break;

			}

		}

		return (0);

	}

	if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) {

		if (hdl != NULL)

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "snapshot delimiter '@' in filesystem name"));

		return (0);

	}

	if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) {

		if (hdl != NULL)

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "missing '@' delimiter in snapshot name"));

		return (0);

	}

	if (modifying && strchr(path, '%') != NULL) {

		if (hdl != NULL)

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "invalid character %c in name"), '%');

		return (0);

	}

	return (-1);

}

int

zfs_name_valid(const char *name, zfs_type_t type)

{

	if (type == ZFS_TYPE_POOL)

		return (zpool_name_valid(NULL, B_FALSE, name));

	return (zfs_validate_name(NULL, name, type, B_FALSE));

}

/*

 * This function takes the raw DSL properties, and filters out the user-defined

 * properties into a separate nvlist.

 */

static nvlist_t *

process_user_props(zfs_handle_t *zhp, nvlist_t *props)

{

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	nvpair_t *elem;

	nvlist_t *propval;

	nvlist_t *nvl;

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {

		(void) no_memory(hdl);

		return (NULL);

	}

	elem = NULL;

	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {

		if (!zfs_prop_user(nvpair_name(elem)))

			continue;

		verify(nvpair_value_nvlist(elem, &propval) == 0);

		if (nvlist_add_nvlist(nvl, nvpair_name(elem), propval) != 0) {

			nvlist_free(nvl);

			(void) no_memory(hdl);

			return (NULL);

		}

	}

	return (nvl);

}

static zpool_handle_t *

zpool_add_handle(zfs_handle_t *zhp, const char *pool_name)

{

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	zpool_handle_t *zph;

	if ((zph = zpool_open_canfail(hdl, pool_name)) != NULL) {

		if (hdl->libzfs_pool_handles != NULL)

			zph->zpool_next = hdl->libzfs_pool_handles;

		hdl->libzfs_pool_handles = zph;

	}

	return (zph);

}

static zpool_handle_t *

zpool_find_handle(zfs_handle_t *zhp, const char *pool_name, int len)

{

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	zpool_handle_t *zph = hdl->libzfs_pool_handles;

	while ((zph != NULL) &&

	    (strncmp(pool_name, zpool_get_name(zph), len) != 0))

		zph = zph->zpool_next;

	return (zph);

}

/*

 * Returns a handle to the pool that contains the provided dataset.

 * If a handle to that pool already exists then that handle is returned.

 * Otherwise, a new handle is created and added to the list of handles.

 */

static zpool_handle_t *

zpool_handle(zfs_handle_t *zhp)

{

	char *pool_name;

	int len;

	zpool_handle_t *zph;

	len = strcspn(zhp->zfs_name, "/@") + 1;

	pool_name = zfs_alloc(zhp->zfs_hdl, len);

	(void) strlcpy(pool_name, zhp->zfs_name, len);

	zph = zpool_find_handle(zhp, pool_name, len);

	if (zph == NULL)

		zph = zpool_add_handle(zhp, pool_name);

	free(pool_name);

	return (zph);

}

void

zpool_free_handles(libzfs_handle_t *hdl)

{

	zpool_handle_t *next, *zph = hdl->libzfs_pool_handles;

	while (zph != NULL) {

		next = zph->zpool_next;

		zpool_close(zph);

		zph = next;

	}

	hdl->libzfs_pool_handles = NULL;

}

/*

 * Utility function to gather stats (objset and zpl) for the given object.

 */

static int

get_stats_ioctl(zfs_handle_t *zhp, zfs_cmd_t *zc)

{

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));

	while (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, zc) != 0) {

		if (errno == ENOMEM) {

			if (zcmd_expand_dst_nvlist(hdl, zc) != 0) {

				return (-1);

			}

		} else {

			return (-1);

		}

	}

	return (0);

}

/*

 * Utility function to get the received properties of the given object.

 */

static int

get_recvd_props_ioctl(zfs_handle_t *zhp)

{

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	nvlist_t *recvdprops;

	zfs_cmd_t zc = { 0 };

	int err;

	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)

		return (-1);

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	while (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_RECVD_PROPS, &zc) != 0) {

		if (errno == ENOMEM) {

			if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {

				return (-1);

			}

		} else {

			zcmd_free_nvlists(&zc);

			return (-1);

		}

	}

	err = zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &recvdprops);

	zcmd_free_nvlists(&zc);

	if (err != 0)

		return (-1);

	nvlist_free(zhp->zfs_recvd_props);

	zhp->zfs_recvd_props = recvdprops;

	return (0);

}

static int

put_stats_zhdl(zfs_handle_t *zhp, zfs_cmd_t *zc)

{

	nvlist_t *allprops, *userprops;

	zhp->zfs_dmustats = zc->zc_objset_stats; /* structure assignment */

	if (zcmd_read_dst_nvlist(zhp->zfs_hdl, zc, &allprops) != 0) {

		return (-1);

	}

	/*

	 * XXX Why do we store the user props separately, in addition to

	 * storing them in zfs_props?

	 */

	if ((userprops = process_user_props(zhp, allprops)) == NULL) {

		nvlist_free(allprops);

		return (-1);

	}

	nvlist_free(zhp->zfs_props);

	nvlist_free(zhp->zfs_user_props);

	zhp->zfs_props = allprops;

	zhp->zfs_user_props = userprops;

	return (0);

}

static int

get_stats(zfs_handle_t *zhp)

{

	int rc = 0;

	zfs_cmd_t zc = { 0 };

	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)

		return (-1);

	if (get_stats_ioctl(zhp, &zc) != 0)

		rc = -1;

	else if (put_stats_zhdl(zhp, &zc) != 0)

		rc = -1;

	zcmd_free_nvlists(&zc);

	return (rc);

}

/*

 * Refresh the properties currently stored in the handle.

 */

void

zfs_refresh_properties(zfs_handle_t *zhp)

{

	(void) get_stats(zhp);

}

/*

 * Makes a handle from the given dataset name.  Used by zfs_open() and

 * zfs_iter_* to create child handles on the fly.

 */

static int

make_dataset_handle_common(zfs_handle_t *zhp, zfs_cmd_t *zc)

{

	if (put_stats_zhdl(zhp, zc) != 0)

		return (-1);

	/*

	 * We've managed to open the dataset and gather statistics.  Determine

	 * the high-level type.

	 */

	if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)

		zhp->zfs_head_type = ZFS_TYPE_VOLUME;

	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)

		zhp->zfs_head_type = ZFS_TYPE_FILESYSTEM;

	else

		abort();

	if (zhp->zfs_dmustats.dds_is_snapshot)

		zhp->zfs_type = ZFS_TYPE_SNAPSHOT;

	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)

		zhp->zfs_type = ZFS_TYPE_VOLUME;

	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)

		zhp->zfs_type = ZFS_TYPE_FILESYSTEM;

	else

		abort();	/* we should never see any other types */

	if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL)

		return (-1);

	return (0);

}

zfs_handle_t *

make_dataset_handle(libzfs_handle_t *hdl, const char *path)

{

	zfs_cmd_t zc = { 0 };

	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);

	if (zhp == NULL)

		return (NULL);

	zhp->zfs_hdl = hdl;

	(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));

	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) {

		free(zhp);

		return (NULL);

	}

	if (get_stats_ioctl(zhp, &zc) == -1) {

		zcmd_free_nvlists(&zc);

		free(zhp);

		return (NULL);

	}

	if (make_dataset_handle_common(zhp, &zc) == -1) {

		free(zhp);

		zhp = NULL;

	}

	zcmd_free_nvlists(&zc);

	return (zhp);

}

static zfs_handle_t *

make_dataset_handle_zc(libzfs_handle_t *hdl, zfs_cmd_t *zc)

{

	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);