/*

 * 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

 */

/*

 * Use is subject to license terms.

 */

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <libgen.h>

#include <libintl.h>

#include <libuutil.h>

#include <libnvpair.h>

#include <locale.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <unistd.h>

#include <fcntl.h>

#include <zone.h>

#include <sys/mkdev.h>

#include <sys/mntent.h>

#include <sys/mnttab.h>

#include <sys/mount.h>

#include <sys/stat.h>

#include <sys/avl.h>

#include <libzfs.h>

#include <libuutil.h>

#include "zfs_iter.h"

#include "zfs_util.h"

libzfs_handle_t *g_zfs;

static FILE *mnttab_file;

static char history_str[HIS_MAX_RECORD_LEN];

static int zfs_do_clone(int argc, char **argv);

static int zfs_do_create(int argc, char **argv);

static int zfs_do_destroy(int argc, char **argv);

static int zfs_do_get(int argc, char **argv);

static int zfs_do_inherit(int argc, char **argv);

static int zfs_do_list(int argc, char **argv);

static int zfs_do_mount(int argc, char **argv);

static int zfs_do_rename(int argc, char **argv);

static int zfs_do_rollback(int argc, char **argv);

static int zfs_do_set(int argc, char **argv);

static int zfs_do_upgrade(int argc, char **argv);

static int zfs_do_snapshot(int argc, char **argv);

static int zfs_do_unmount(int argc, char **argv);

static int zfs_do_share(int argc, char **argv);

static int zfs_do_unshare(int argc, char **argv);

static int zfs_do_send(int argc, char **argv);

static int zfs_do_receive(int argc, char **argv);

static int zfs_do_promote(int argc, char **argv);

static int zfs_do_allow(int argc, char **argv);

static int zfs_do_unallow(int argc, char **argv);

/*

 * Enable a reasonable set of defaults for libumem debugging on DEBUG builds.

 */

#ifdef DEBUG

const char *

_umem_debug_init(void)

{

	return ("default,verbose"); /* $UMEM_DEBUG setting */

}

const char *

_umem_logging_init(void)

{

	return ("fail,contents"); /* $UMEM_LOGGING setting */

}

#endif

typedef enum {

	HELP_CLONE,

	HELP_CREATE,

	HELP_DESTROY,

	HELP_GET,

	HELP_INHERIT,

	HELP_UPGRADE,

	HELP_LIST,

	HELP_MOUNT,

	HELP_PROMOTE,

	HELP_RECEIVE,

	HELP_RENAME,

	HELP_ROLLBACK,

	HELP_SEND,

	HELP_SET,

	HELP_SHARE,

	HELP_SNAPSHOT,

	HELP_UNMOUNT,

	HELP_UNSHARE,

	HELP_ALLOW,

	HELP_UNALLOW

} zfs_help_t;

typedef struct zfs_command {

	const char	*name;

	int		(*func)(int argc, char **argv);

	zfs_help_t	usage;

} zfs_command_t;

/*

 * Master command table.  Each ZFS command has a name, associated function, and

 * usage message.  The usage messages need to be internationalized, so we have

 * to have a function to return the usage message based on a command index.

 *

 * These commands are organized according to how they are displayed in the usage

 * message.  An empty command (one with a NULL name) indicates an empty line in

 * the generic usage message.

 */

static zfs_command_t command_table[] = {

	{ "create",	zfs_do_create,		HELP_CREATE		},

	{ "destroy",	zfs_do_destroy,		HELP_DESTROY		},

	{ NULL },

	{ "snapshot",	zfs_do_snapshot,	HELP_SNAPSHOT		},

	{ "rollback",	zfs_do_rollback,	HELP_ROLLBACK		},

	{ "clone",	zfs_do_clone,		HELP_CLONE		},

	{ "promote",	zfs_do_promote,		HELP_PROMOTE		},

	{ "rename",	zfs_do_rename,		HELP_RENAME		},

	{ NULL },

	{ "list",	zfs_do_list,		HELP_LIST		},

	{ NULL },

	{ "set",	zfs_do_set,		HELP_SET		},

	{ "get", 	zfs_do_get,		HELP_GET		},

	{ "inherit",	zfs_do_inherit,		HELP_INHERIT		},

	{ "upgrade",	zfs_do_upgrade,		HELP_UPGRADE		},

	{ NULL },

	{ "mount",	zfs_do_mount,		HELP_MOUNT		},

	{ "unmount",	zfs_do_unmount,		HELP_UNMOUNT		},

	{ "share",	zfs_do_share,		HELP_SHARE		},

	{ "unshare",	zfs_do_unshare,		HELP_UNSHARE		},

	{ NULL },

	{ "send",	zfs_do_send,		HELP_SEND		},

	{ "receive",	zfs_do_receive,		HELP_RECEIVE		},

	{ NULL },

	{ "allow",	zfs_do_allow,		HELP_ALLOW		},

	{ NULL },

	{ "unallow",	zfs_do_unallow,		HELP_UNALLOW		},

};

#define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))

zfs_command_t *current_command;

static const char *

get_usage(zfs_help_t idx)

{

	switch (idx) {

	case HELP_CLONE:

		return (gettext("\tclone [-p] [-o property=value] ... "

		    "<snapshot> <filesystem|volume>\n"));

	case HELP_CREATE:

		return (gettext("\tcreate [-p] [-o property=value] ... "

		    "<filesystem>\n"

		    "\tcreate [-ps] [-b blocksize] [-o property=value] ... "

		    "-V <size> <volume>\n"));

	case HELP_DESTROY:

		return (gettext("\tdestroy [-rRf] "

		    "<filesystem|volume|snapshot>\n"));

	case HELP_GET:

		return (gettext("\tget [-rHp] [-o field[,...]] "

		    "[-s source[,...]]\n"

		    "\t    <\"all\" | property[,...]> "

		    "[filesystem|volume|snapshot] ...\n"));

	case HELP_INHERIT:

		return (gettext("\tinherit [-r] <property> "

		    "<filesystem|volume|snapshot> ...\n"));

	case HELP_UPGRADE:

		return (gettext("\tupgrade [-v]\n"

		    "\tupgrade [-r] [-V version] <-a | filesystem ...>\n"));

	case HELP_LIST:

		return (gettext("\tlist [-rH] [-o property[,...]] "

		    "[-t type[,...]] [-s property] ...\n"

		    "\t    [-S property] ... "

		    "[filesystem|volume|snapshot] ...\n"));

	case HELP_MOUNT:

		return (gettext("\tmount\n"

		    "\tmount [-vO] [-o opts] <-a | filesystem>\n"));

	case HELP_PROMOTE:

		return (gettext("\tpromote <clone-filesystem>\n"));

	case HELP_RECEIVE:

		return (gettext("\treceive [-vnF] <filesystem|volume|"

		"snapshot>\n"

		"\treceive [-vnF] -d <filesystem>\n"));

	case HELP_RENAME:

		return (gettext("\trename <filesystem|volume|snapshot> "

		    "<filesystem|volume|snapshot>\n"

		    "\trename -p <filesystem|volume> <filesystem|volume>\n"

		    "\trename -r <snapshot> <snapshot>"));

	case HELP_ROLLBACK:

		return (gettext("\trollback [-rRf] <snapshot>\n"));

	case HELP_SEND:

		return (gettext("\tsend [-R] [-[iI] snapshot] <snapshot>\n"));

	case HELP_SET:

		return (gettext("\tset <property=value> "

		    "<filesystem|volume|snapshot> ...\n"));

	case HELP_SHARE:

		return (gettext("\tshare <-a | filesystem>\n"));

	case HELP_SNAPSHOT:

		return (gettext("\tsnapshot [-r] [-o property=value] ... "

		    "<filesystem@snapname|volume@snapname>\n"));

	case HELP_UNMOUNT:

		return (gettext("\tunmount [-f] "

		    "<-a | filesystem|mountpoint>\n"));

	case HELP_UNSHARE:

		return (gettext("\tunshare [-f] "

		    "<-a | filesystem|mountpoint>\n"));

	case HELP_ALLOW:

		return (gettext("\tallow [-ldug] "

		    "<\"everyone\"|user|group>[,...] <perm|@setname>[,...]\n"

		    "\t    <filesystem|volume>\n"

		    "\tallow [-ld] -e <perm|@setname>[,...] "

		    "<filesystem|volume>\n"

		    "\tallow -c <perm|@setname>[,...] <filesystem|volume>\n"

		    "\tallow -s @setname <perm|@setname>[,...] "

		    "<filesystem|volume>\n"));

	case HELP_UNALLOW:

		return (gettext("\tunallow [-rldug] "

		    "<\"everyone\"|user|group>[,...]\n"

		    "\t    [<perm|@setname>[,...]] <filesystem|volume>\n"

		    "\tunallow [-rld] -e [<perm|@setname>[,...]] "

		    "<filesystem|volume>\n"

		    "\tunallow [-r] -c [<perm|@setname>[,...]] "

		    "<filesystem|volume>\n"

		    "\tunallow [-r] -s @setname [<perm|@setname>[,...]] "

		    "<filesystem|volume>\n"));

	}

	abort();

	/* NOTREACHED */

}

/*

 * Utility function to guarantee malloc() success.

 */

void *

safe_malloc(size_t size)

{

	void *data;

	if ((data = calloc(1, size)) == NULL) {

		(void) fprintf(stderr, "internal error: out of memory\n");

		exit(1);

	}

	return (data);

}

/*

 * Callback routine that will print out information for each of

 * the properties.

 */

static int

usage_prop_cb(int prop, void *cb)

{

	FILE *fp = cb;

	(void) fprintf(fp, "\t%-15s ", zfs_prop_to_name(prop));

	if (zfs_prop_readonly(prop))

		(void) fprintf(fp, " NO    ");

	else

		(void) fprintf(fp, "YES    ");

	if (zfs_prop_inheritable(prop))

		(void) fprintf(fp, "  YES   ");

	else

		(void) fprintf(fp, "   NO   ");

	if (zfs_prop_values(prop) == NULL)

		(void) fprintf(fp, "-\n");

	else

		(void) fprintf(fp, "%s\n", zfs_prop_values(prop));

	return (ZPROP_CONT);

}

/*

 * Display usage message.  If we're inside a command, display only the usage for

 * that command.  Otherwise, iterate over the entire command table and display

 * a complete usage message.

 */

static void

usage(boolean_t requested)

{

	int i;

	boolean_t show_properties = B_FALSE;

	boolean_t show_permissions = B_FALSE;

	FILE *fp = requested ? stdout : stderr;

	if (current_command == NULL) {

		(void) fprintf(fp, gettext("usage: zfs command args ...\n"));

		(void) fprintf(fp,

		    gettext("where 'command' is one of the following:\n\n"));

		for (i = 0; i < NCOMMAND; i++) {

			if (command_table[i].name == NULL)

				(void) fprintf(fp, "\n");

			else

				(void) fprintf(fp, "%s",

				    get_usage(command_table[i].usage));

		}

		(void) fprintf(fp, gettext("\nEach dataset is of the form: "

		    "pool/[dataset/]*dataset[@name]\n"));

	} else {

		(void) fprintf(fp, gettext("usage:\n"));

		(void) fprintf(fp, "%s", get_usage(current_command->usage));

	}

	if (current_command != NULL &&

	    (strcmp(current_command->name, "set") == 0 ||

	    strcmp(current_command->name, "get") == 0 ||

	    strcmp(current_command->name, "inherit") == 0 ||

	    strcmp(current_command->name, "list") == 0))

		show_properties = B_TRUE;

	if (current_command != NULL &&

	    (strcmp(current_command->name, "allow") == 0 ||

	    strcmp(current_command->name, "unallow") == 0))

		show_permissions = B_TRUE;

	if (show_properties) {

		(void) fprintf(fp,

		    gettext("\nThe following properties are supported:\n"));

		(void) fprintf(fp, "\n\t%-14s %s  %s   %s\n\n",

		    "PROPERTY", "EDIT", "INHERIT", "VALUES");

		/* Iterate over all properties */

		(void) zprop_iter(usage_prop_cb, fp, B_FALSE, B_TRUE,

		    ZFS_TYPE_DATASET);

		(void) fprintf(fp, gettext("\nSizes are specified in bytes "

		    "with standard units such as K, M, G, etc.\n"));

		(void) fprintf(fp, gettext("\nUser-defined properties can "

		    "be specified by using a name containing a colon (:).\n"));

	} else if (show_permissions) {

		(void) fprintf(fp,

		    gettext("\nThe following permissions are supported:\n"));

		zfs_deleg_permissions();

	} else {

		(void) fprintf(fp,

		    gettext("\nFor the property list, run: %s\n"),

		    "zfs set|get");

		(void) fprintf(fp,

		    gettext("\nFor the delegated permission list, run: %s\n"),

		    "zfs allow|unallow");

	}

	/*

	 * See comments at end of main().

	 */

	if (getenv("ZFS_ABORT") != NULL) {

		(void) printf("dumping core by request\n");

		abort();

	}

	exit(requested ? 0 : 2);

}

static int

parseprop(nvlist_t *props)

{

	char *propname = optarg;

	char *propval, *strval;

	if ((propval = strchr(propname, '=')) == NULL) {

		(void) fprintf(stderr, gettext("missing "

		    "'=' for -o option\n"));

		return (-1);

	}

	*propval = '\0';

	propval++;

	if (nvlist_lookup_string(props, propname, &strval) == 0) {

		(void) fprintf(stderr, gettext("property '%s' "

		    "specified multiple times\n"), propname);

		return (-1);

	}

	if (nvlist_add_string(props, propname, propval) != 0) {

		(void) fprintf(stderr, gettext("internal "

		    "error: out of memory\n"));

		return (-1);

	}

	return (0);

}

/*

 * zfs clone [-p] [-o prop=value] ... <snap> <fs | vol>

 *

 * Given an existing dataset, create a writable copy whose initial contents

 * are the same as the source.  The newly created dataset maintains a

 * dependency on the original; the original cannot be destroyed so long as

 * the clone exists.

 *

 * The '-p' flag creates all the non-existing ancestors of the target first.

 */

static int

zfs_do_clone(int argc, char **argv)

{

	zfs_handle_t *zhp = NULL;

	boolean_t parents = B_FALSE;

	nvlist_t *props;

	int ret;

	int c;

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

		(void) fprintf(stderr, gettext("internal error: "

		    "out of memory\n"));

		return (1);

	}

	/* check options */

	while ((c = getopt(argc, argv, "o:p")) != -1) {

		switch (c) {

		case 'o':

			if (parseprop(props))

				return (1);

			break;

		case 'p':

			parents = B_TRUE;

			break;

		case '?':

			(void) fprintf(stderr, gettext("invalid option '%c'\n"),

			    optopt);

			goto usage;

		}

	}

	argc -= optind;

	argv += optind;

	/* check number of arguments */

	if (argc < 1) {

		(void) fprintf(stderr, gettext("missing source dataset "

		    "argument\n"));

		goto usage;

	}

	if (argc < 2) {

		(void) fprintf(stderr, gettext("missing target dataset "

		    "argument\n"));

		goto usage;

	}

	if (argc > 2) {

		(void) fprintf(stderr, gettext("too many arguments\n"));

		goto usage;

	}

	/* open the source dataset */

	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)

		return (1);

	if (parents && zfs_name_valid(argv[1], ZFS_TYPE_FILESYSTEM |

	    ZFS_TYPE_VOLUME)) {

		/*

		 * Now create the ancestors of the target dataset.  If the

		 * target already exists and '-p' option was used we should not

		 * complain.

		 */

		if (zfs_dataset_exists(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM |

		    ZFS_TYPE_VOLUME))

			return (0);

		if (zfs_create_ancestors(g_zfs, argv[1]) != 0)

			return (1);

	}