/*

 * 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 2007 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 <libgen.h>

#include <libintl.h>

#include <libuutil.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 <libzfs.h>

#include "zfs_iter.h"

#include "zfs_util.h"

libzfs_handle_t *g_zfs;

static FILE *mnttab_file;

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

/*

 * These libumem hooks provide a reasonable set of defaults for the allocator's

 * debugging facilities.

 */

const char *

_umem_debug_init(void)

{

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

}

const char *

_umem_logging_init(void)

{

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

}

typedef enum {

	HELP_CLONE,

	HELP_CREATE,

	HELP_DESTROY,

	HELP_GET,

	HELP_INHERIT,

	HELP_LIST,

	HELP_MOUNT,

	HELP_PROMOTE,

	HELP_RECEIVE,

	HELP_RENAME,

	HELP_ROLLBACK,

	HELP_SEND,

	HELP_SET,

	HELP_SHARE,

	HELP_SNAPSHOT,

	HELP_UNMOUNT,

	HELP_UNSHARE

} 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		},

	{ NULL },

	{ "mount",	zfs_do_mount,		HELP_MOUNT		},

	{ NULL },

	{ "unmount",	zfs_do_unmount,		HELP_UNMOUNT		},

	{ NULL },

	{ "share",	zfs_do_share,		HELP_SHARE		},

	{ NULL },

	{ "unshare",	zfs_do_unshare,		HELP_UNSHARE		},

	{ NULL },

	{ "send",	zfs_do_send,		HELP_SEND		},

	{ "receive",	zfs_do_receive,		HELP_RECEIVE		},

};

#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 <snapshot> <filesystem|volume>\n"));

	case HELP_CREATE:

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

		    "<filesystem>\n"

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

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

	case HELP_DESTROY:

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

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

	case HELP_GET:

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

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

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

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

	case HELP_INHERIT:

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

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

	case HELP_LIST:

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

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

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

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

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

	case HELP_MOUNT:

		return (gettext("\tmount\n"

		    "\tmount [-o opts] [-O] -a\n"

		    "\tmount [-o opts] [-O] <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"));

	case HELP_ROLLBACK:

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

	case HELP_SEND:

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

	case HELP_SET:

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

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

	case HELP_SHARE:

		return (gettext("\tshare -a\n"

		    "\tshare <filesystem>\n"));

	case HELP_SNAPSHOT:

		return (gettext("\tsnapshot [-r] "

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

	case HELP_UNMOUNT:

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

		    "\tunmount [-f] <filesystem|mountpoint>\n"));

	case HELP_UNSHARE:

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

		    "\tunshare [-f] <filesystem|mountpoint>\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);

}

/*

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

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

		(void) fprintf(fp,

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

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

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

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

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

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

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

	} else {

		/*

		 * TRANSLATION NOTE:

		 * "zfs set|get" must not be localised this is the

		 * command name and arguments.

		 */

		(void) fprintf(fp,

		    gettext("\nFor the property list, run: zfs set|get\n"));

	}

	/*

	 * See comments at end of main().

	 */

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

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

		abort();

	}

	exit(requested ? 0 : 2);

}

/*

 * zfs clone <fs, snap, vol> fs

 *

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

 */

static int

zfs_do_clone(int argc, char **argv)

{

	zfs_handle_t *zhp;

	int ret;

	/* check options */

	if (argc > 1 && argv[1][0] == '-') {

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

		    argv[1][1]);

		usage(B_FALSE);

	}

	/* check number of arguments */

	if (argc < 2) {

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

		    "argument\n"));

		usage(B_FALSE);

	}

	if (argc < 3) {

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

		    "argument\n"));

		usage(B_FALSE);

	}

	if (argc > 3) {

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

		usage(B_FALSE);

	}

	/* open the source dataset */

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

		return (1);

	/* pass to libzfs */

	ret = zfs_clone(zhp, argv[2], NULL);

	/* create the mountpoint if necessary */

	if (ret == 0) {

		zfs_handle_t *clone = zfs_open(g_zfs, argv[2], ZFS_TYPE_ANY);

		if (clone != NULL) {

			if ((ret = zfs_mount(clone, NULL, 0)) == 0)

				ret = zfs_share(clone);

			zfs_close(clone);

		}

		zpool_log_history(g_zfs, argc, argv, argv[2], B_FALSE, B_FALSE);

	}

	zfs_close(zhp);

	return (ret == 0 ? 0 : 1);

}

/*

 * zfs create [-o prop=value] ... fs

 * zfs create [-s] [-b blocksize] [-o prop=value] ... -V vol size

 *

 * Create a new dataset.  This command can be used to create filesystems

 * and volumes.  Snapshot creation is handled by 'zfs snapshot'.

 * For volumes, the user must specify a size to be used.

 *

 * The '-s' flag applies only to volumes, and indicates that we should not try

 * to set the reservation for this volume.  By default we set a reservation

 * equal to the size for any volume.

 */

static int

zfs_do_create(int argc, char **argv)

{

	zfs_type_t type = ZFS_TYPE_FILESYSTEM;

	zfs_handle_t *zhp = NULL;

	uint64_t volsize;

	int c;

	boolean_t noreserve = B_FALSE;

	int ret = 1;

	nvlist_t *props = NULL;

	uint64_t intval;

	char *propname;

	char *propval = NULL;

	char *strval;

	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, ":V:b:so:")) != -1) {

		switch (c) {

		case 'V':

			type = ZFS_TYPE_VOLUME;

			if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {

				(void) fprintf(stderr, gettext("bad volume "

				    "size '%s': %s\n"), optarg,

				    libzfs_error_description(g_zfs));

				goto error;

			}

			if (nvlist_add_uint64(props,

			    zfs_prop_to_name(ZFS_PROP_VOLSIZE),

			    intval) != 0) {

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

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

				goto error;

			}

			volsize = intval;

			break;

		case 'b':

			if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {

				(void) fprintf(stderr, gettext("bad volume "

				    "block size '%s': %s\n"), optarg,

				    libzfs_error_description(g_zfs));

				goto error;

			}

			if (nvlist_add_uint64(props,

			    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),

			    intval) != 0) {

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

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

				goto error;

			}

			break;

		case 'o':

			propname = optarg;

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

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

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

				goto error;

			}

			*propval = '\0';

			propval++;

			if (nvlist_lookup_string(props, propname,

			    &strval) == 0) {

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

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

				goto error;

			}

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

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

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

				goto error;

			}

			break;

		case 's':

			noreserve = B_TRUE;

			break;

		case ':':

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

			    "argument\n"));

			goto badusage;