/*

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

 * Use is subject to license terms.

 */

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

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <libdevinfo.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/mnttab.h>

#include <sys/mount.h>

#include <sys/avl.h>

#include <priv.h>

#include <pwd.h>

#include <grp.h>

#include <stddef.h>

#include <ucred.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 zvol_create_link_common(libzfs_handle_t *, const char *, int);

/*

 * 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 place a more useful message in

 * 'buf' detailing 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)

{

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

}

/*

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

 */

static int

get_stats(zfs_handle_t *zhp)

{

	zfs_cmd_t zc = { 0 };

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	nvlist_t *allprops, *userprops;

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

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

		return (-1);

	while (ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) {

		if (errno == ENOMEM) {

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

				zcmd_free_nvlists(&zc);

				return (-1);

			}

		} else {

			zcmd_free_nvlists(&zc);

			return (-1);

		}

	}

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

	(void) strlcpy(zhp->zfs_root, zc.zc_value, sizeof (zhp->zfs_root));

	if (zcmd_read_dst_nvlist(hdl, &zc, &allprops) != 0) {

		zcmd_free_nvlists(&zc);

		return (-1);

	}

	zcmd_free_nvlists(&zc);

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

}

/*

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

 */

zfs_handle_t *

make_dataset_handle(libzfs_handle_t *hdl, const char *path)

{

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

	char *logstr;

	if (zhp == NULL)

		return (NULL);

	zhp->zfs_hdl = hdl;

	/*

	 * Preserve history log string.

	 * any changes performed here will be

	 * logged as an internal event.

	 */

	logstr = zhp->zfs_hdl->libzfs_log_str;

	zhp->zfs_hdl->libzfs_log_str = NULL;

top:

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

	if (get_stats(zhp) != 0) {

		zhp->zfs_hdl->libzfs_log_str = logstr;

		free(zhp);

		return (NULL);

	}

	if (zhp->zfs_dmustats.dds_inconsistent) {

		zfs_cmd_t zc = { 0 };

		/*

		 * If it is dds_inconsistent, then we've caught it in

		 * the middle of a 'zfs receive' or 'zfs destroy', and

		 * it is inconsistent from the ZPL's point of view, so

		 * can't be mounted.  However, it could also be that we

		 * have crashed in the middle of one of those

		 * operations, in which case we need to get rid of the

		 * inconsistent state.  We do that by either rolling

		 * back to the previous snapshot (which will fail if

		 * there is none), or destroying the filesystem.  Note

		 * that if we are still in the middle of an active

		 * 'receive' or 'destroy', then the rollback and destroy

		 * will fail with EBUSY and we will drive on as usual.

		 */

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

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

			(void) zvol_remove_link(hdl, zhp->zfs_name);

			zc.zc_objset_type = DMU_OST_ZVOL;

		} else {

			zc.zc_objset_type = DMU_OST_ZFS;

		}

		/*

		 * If we can successfully destroy it, pretend that it

		 * never existed.

		 */

		if (ioctl(hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc) == 0) {

			zhp->zfs_hdl->libzfs_log_str = logstr;

			free(zhp);

			errno = ENOENT;

			return (NULL);

		}

		/* If we can successfully roll it back, reget the stats */

		if (ioctl(hdl->libzfs_fd, ZFS_IOC_ROLLBACK, &zc) == 0)

			goto top;

	}

	/*

	 * 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 */

	zhp->zfs_hdl->libzfs_log_str = logstr;

	return (zhp);

}

/*

 * Opens the given snapshot, filesystem, or volume.   The 'types'

 * argument is a mask of acceptable types.  The function will print an

 * appropriate error message and return NULL if it can't be opened.

 */

zfs_handle_t *

zfs_open(libzfs_handle_t *hdl, const char *path, int types)

{

	zfs_handle_t *zhp;

	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf),

	    dgettext(TEXT_DOMAIN, "cannot open '%s'"), path);

	/*

	 * Validate the name before we even try to open it.

	 */

	if (!zfs_validate_name(hdl, path, ZFS_TYPE_DATASET, B_FALSE)) {

		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

		    "invalid dataset name"));

		(void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);

		return (NULL);

	}

	/*

	 * Try to get stats for the dataset, which will tell us if it exists.

	 */

	errno = 0;

	if ((zhp = make_dataset_handle(hdl, path)) == NULL) {

		(void) zfs_standard_error(hdl, errno, errbuf);

		return (NULL);

	}

	if (!(types & zhp->zfs_type)) {

		(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);

		zfs_close(zhp);

		return (NULL);

	}

	return (zhp);

}

/*

 * Release a ZFS handle.  Nothing to do but free the associated memory.

 */

void

zfs_close(zfs_handle_t *zhp)

{

	if (zhp->zfs_mntopts)

		free(zhp->zfs_mntopts);

	nvlist_free(zhp->zfs_props);

	nvlist_free(zhp->zfs_user_props);

	free(zhp);

}

int

zfs_spa_version(zfs_handle_t *zhp, int *spa_version)

{

	char *pool_name;

	zpool_handle_t *zpool_handle;

	char *p;

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

	if (zfs_prop_get(zhp, ZFS_PROP_NAME, pool_name,

	    MAXPATHLEN, NULL, NULL, 0, B_FALSE) != 0) {

		free(pool_name);

		return (-1);

	}

	if (p = strchr(pool_name, '/'))

		*p = '\0';

	zpool_handle = zpool_open(zhp->zfs_hdl, pool_name);

	free(pool_name);

	if (zpool_handle == NULL)

		return (-1);

	*spa_version = zpool_get_prop_int(zpool_handle,

	    ZPOOL_PROP_VERSION, NULL);

	zpool_close(zpool_handle);

	return (0);

}

/*

 * The choice of reservation property depends on the SPA version.

 */

static int

zfs_which_resv_prop(zfs_handle_t *zhp, zfs_prop_t *resv_prop)

{