/*

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

#include <fcntl.h>

#include <sys/mntent.h>

#include <sys/mnttab.h>

#include <sys/mount.h>

#include <sys/spa.h>

#include <sys/zio.h>

#include <libzfs.h>

#include "zfs_namecheck.h"

#include "zfs_prop.h"

#include "libzfs_impl.h"

/*

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

{

	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;

			}

		}

		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 '@' delimeter in snapshot name"));

		return (0);

	}

	return (-1);

}

int

zfs_name_valid(const char *name, zfs_type_t type)

{

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

}

/*

 * 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 };

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

	if ((zc.zc_config_src = (uint64_t)(uintptr_t)malloc(1024)) == NULL)

		return (-1);

	zc.zc_config_src_size = 1024;

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

		if (errno == ENOMEM) {

			free((void *)(uintptr_t)zc.zc_config_src);

			if ((zc.zc_config_src = (uint64_t)(uintptr_t)

			    malloc(zc.zc_config_src_size)) == NULL)

				return (-1);

		} else {

			free((void *)(uintptr_t)zc.zc_config_src);

			return (-1);

		}

	}

	bcopy(&zc.zc_objset_stats, &zhp->zfs_dmustats,

	    sizeof (zc.zc_objset_stats));

	(void) strcpy(zhp->zfs_root, zc.zc_root);

	if (zhp->zfs_props) {

		nvlist_free(zhp->zfs_props);

		zhp->zfs_props = NULL;

	}

	if (nvlist_unpack((void *)(uintptr_t)zc.zc_config_src,

	    zc.zc_config_src_size, &zhp->zfs_props, 0) != 0) {

		free((void *)(uintptr_t)zc.zc_config_src);

		return (-1);

	}

	zhp->zfs_volsize = zc.zc_volsize;

	zhp->zfs_volblocksize = zc.zc_volblocksize;

	free((void *)(uintptr_t)zc.zc_config_src);

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

	if (zhp == NULL)

		return (NULL);

	zhp->zfs_hdl = hdl;

top:

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

	if (get_stats(zhp) != 0) {

		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_type == ZFS_TYPE_VOLUME) {

			(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 roll it back, reget the stats */

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

			goto top;

		/*

		 * If we can sucessfully destroy it, pretend that it

		 * never existed.

		 */

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

			free(zhp);

			errno = ENOENT;

			return (NULL);

		}

	}

	/*

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

	 * the high-level type.

	 */

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

	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_ANY)) {

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

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

	if (zhp->zfs_props)

		nvlist_free(zhp->zfs_props);

	free(zhp);

}

struct {

	const char *name;

	uint64_t value;

} checksum_table[] = {

	{ "on",		ZIO_CHECKSUM_ON },

	{ "off",	ZIO_CHECKSUM_OFF },

	{ "fletcher2",	ZIO_CHECKSUM_FLETCHER_2 },

	{ "fletcher4",	ZIO_CHECKSUM_FLETCHER_4 },

	{ "sha256",	ZIO_CHECKSUM_SHA256 },

	{ NULL }

};

struct {

	const char *name;

	uint64_t value;

} compress_table[] = {

	{ "on",		ZIO_COMPRESS_ON },

	{ "off",	ZIO_COMPRESS_OFF },

	{ "lzjb",	ZIO_COMPRESS_LZJB },

	{ NULL }

};

struct {

	const char *name;

	uint64_t value;

} snapdir_table[] = {

	{ "hidden",	ZFS_SNAPDIR_HIDDEN },

	{ "visible",	ZFS_SNAPDIR_VISIBLE },

	{ NULL }

};

struct {

	const char *name;

	uint64_t value;

} acl_mode_table[] = {

	{ "discard",	DISCARD },

	{ "groupmask",	GROUPMASK },

	{ "passthrough", PASSTHROUGH },

	{ NULL }

};

struct {

	const char *name;

	uint64_t value;

} acl_inherit_table[] = {

	{ "discard",	DISCARD },

	{ "noallow",	NOALLOW },

	{ "secure",	SECURE },

	{ "passthrough", PASSTHROUGH },

	{ NULL }

};

/*

 * Given a numeric suffix, convert the value into a number of bits that the

 * resulting value must be shifted.

 */

static int

str2shift(libzfs_handle_t *hdl, const char *buf)

{

	const char *ends = "BKMGTPEZ";

	int i;

	if (buf[0] == '\0')

		return (0);

	for (i = 0; i < strlen(ends); i++) {

		if (toupper(buf[0]) == ends[i])

			break;

	}

	if (i == strlen(ends)) {

		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

		    "invalid numeric suffix '%s'"), buf);

		return (-1);

	}

	/*

	 * We want to allow trailing 'b' characters for 'GB' or 'Mb'.  But don't

	 * allow 'BB' - that's just weird.

	 */

	if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' &&

	    toupper(buf[0]) != 'B'))

		return (10*i);

	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

	    "invalid numeric suffix '%s'"), buf);

	return (-1);

}

/*

 * Convert a string of the form '100G' into a real number.  Used when setting

 * properties or creating a volume.  'buf' is used to place an extended error

 * message for the caller to use.

 */

static int

nicestrtonum(libzfs_handle_t *hdl, const char *value, uint64_t *num)

{

	char *end;

	int shift;

	*num = 0;

	/* Check to see if this looks like a number.  */

	if ((value[0] < '0' || value[0] > '9') && value[0] != '.') {

		if (hdl)

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "bad numeric value '%s'"), value);

		return (-1);

	}

	/* Rely on stroll() to process the numeric portion.  */

	errno = 0;

	*num = strtoll(value, &end, 10);

	/*

	 * Check for ERANGE, which indicates that the value is too large to fit

	 * in a 64-bit value.

	 */

	if (errno == ERANGE) {

		if (hdl)

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "numeric value is too large"));

		return (-1);

	}

	/*

	 * If we have a decimal value, then do the computation with floating

	 * point arithmetic.  Otherwise, use standard arithmetic.

	 */

	if (*end == '.') {

		double fval = strtod(value, &end);

		if ((shift = str2shift(hdl, end)) == -1)