/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (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 <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"));

	}

	zfs_baderror(type);

	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(const char *path, int type, char *buf, size_t buflen)

{

	namecheck_err_t why;

	char what;

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

		if (buf != NULL) {

			switch (why) {

			case NAME_ERR_TOOLONG:

				(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

				    "name is too long"), buflen);

				break;

			case NAME_ERR_LEADING_SLASH:

				(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

				    "leading slash"), buflen);

				break;

			case NAME_ERR_EMPTY_COMPONENT:

				(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

				    "empty component"), buflen);

				break;

			case NAME_ERR_TRAILING_SLASH:

				(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

				    "trailing slash"), buflen);

				break;

			case NAME_ERR_INVALCHAR:

				(void) snprintf(buf, buflen,

				    dgettext(TEXT_DOMAIN, "invalid character "

				    "'%c'"), what);

				break;

			case NAME_ERR_MULTIPLE_AT:

				(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

				    "multiple '@' delimiters"), buflen);

				break;

			}

		}

		return (0);

	}

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

		if (buf != NULL)

			(void) strlcpy(buf,

			    dgettext(TEXT_DOMAIN,

			    "snapshot delimiter '@'"), buflen);

		return (0);

	}

	return (1);

}

int

zfs_name_valid(const char *name, zfs_type_t type)

{

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

}

/*

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

	zc.zc_config_src = (uint64_t)(uintptr_t)zfs_malloc(1024);

	zc.zc_config_src_size = 1024;

	while (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) {

		if (errno == ENOMEM) {

			zc.zc_config_src = (uint64_t)(uintptr_t)

			    zfs_malloc(zc.zc_config_src_size);

		} else {

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

			return (-1);

		}

	}

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

	    sizeof (zc.zc_objset_stats));

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

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

	zhp->zfs_volsize = zc.zc_volsize;

	zhp->zfs_volblocksize = zc.zc_volblocksize;

	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(const char *path)

{

	zfs_handle_t *zhp = zfs_malloc(sizeof (zfs_handle_t));

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

	if (get_stats(zhp) != 0) {

		free(zhp);

		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

		/* we should never see any other dataset types */

		zfs_baderror(zhp->zfs_dmustats.dds_type);

	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(const char *path, int types)

{

	zfs_handle_t *zhp;

	/*

	 * Validate the name before we even try to open it.  We don't care about

	 * the verbose invalid messages here; just report a generic error.

	 */

	if (!zfs_validate_name(path, types, NULL, 0)) {

		zfs_error(dgettext(TEXT_DOMAIN,

		    "cannot open '%s': invalid %s name"), path,

		    path_to_str(path, types));

		return (NULL);

	}

	/*

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

	 */

	errno = 0;

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

		switch (errno) {

		case ENOENT:

			/*

			 * The dataset doesn't exist.

			 */

			zfs_error(dgettext(TEXT_DOMAIN,

			    "cannot open '%s': no such %s"), path,

			    path_to_str(path, types));

			break;

		case EBUSY:

			/*

			 * We were able to open the dataset but couldn't

			 * get the stats.

			 */

			zfs_error(dgettext(TEXT_DOMAIN,

			    "cannot open '%s': %s is busy"), path,

			    path_to_str(path, types));

			break;

		default:

			zfs_baderror(errno);

		}

		return (NULL);

	}

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

		zfs_error(dgettext(TEXT_DOMAIN, "cannot open '%s': operation "

		    "not supported for %ss"), path,

		    zfs_type_to_name(zhp->zfs_type));

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

	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(const char *buf, char *reason, size_t len)

{

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

		(void) snprintf(reason, len, 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);

	}

	(void) snprintf(reason, len, 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(const char *value, uint64_t *num, char *buf, size_t buflen)

{

	char *end;

	int shift;

	*num = 0;

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

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

		(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

		    "must be a numeric value"), buflen);

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

		(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

		    "value is too large"), buflen);

		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(end, buf, buflen)) == -1)

			return (-1);

		fval *= pow(2, shift);

		if (fval > UINT64_MAX) {

			(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

			    "value is too large"), buflen);

			return (-1);

		}

		*num = (uint64_t)fval;

	} else {

		if ((shift = str2shift(end, buf, buflen)) == -1)

			return (-1);

		/* Check for overflow */

		if (shift >= 64 || (*num << shift) >> shift != *num) {

			(void) strlcpy(buf, dgettext(TEXT_DOMAIN,

			    "value is too large"), buflen);

			return (-1);

		}

		*num <<= shift;

	}

	return (0);

}

int

zfs_nicestrtonum(const char *str, uint64_t *val)

{

	char buf[1];

	return (nicestrtonum(str, val, buf, sizeof (buf)));

}

/*

 * Given a property type and value, verify that the value is appropriate.  Used

 * by zfs_prop_set() and some libzfs consumers.

 */

int

zfs_prop_validate(zfs_prop_t prop, const char *value, uint64_t *intval)

{

	const char *propname = zfs_prop_to_name(prop);

	uint64_t number;

	char reason[64];

	int i;

	/*

	 * Check to see if this a read-only property.

	 */

	if (zfs_prop_readonly(prop)) {

		zfs_error(dgettext(TEXT_DOMAIN,

		    "cannot set %s property: read-only property"), propname);

		return (-1);

	}

	/* See if the property value is too long */

	if (strlen(value) >= ZFS_MAXPROPLEN) {

		zfs_error(dgettext(TEXT_DOMAIN,

		    "bad %s value '%s': value is too long"), propname,