/*

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

{

	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 <filesystem>\n"

		    "\tcreate [-s] [-b blocksize] -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    [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 [-vn] <filesystem|volume|snapshot>\n"

		    "\treceive [-vn] -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 <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));

	}

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

	    strcmp(current_command->name, "inherit") == 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");

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

			(void) fprintf(fp, "\t%-13s  ", zfs_prop_to_name(i));

			if (zfs_prop_readonly(i))

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

			else

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

			if (zfs_prop_inheritable(i))

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

			else

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

			if (zfs_prop_values(i) == NULL)

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

			else

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

		}

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

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

	}

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

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

		}

	}

	zfs_close(zhp);

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

}

/*

 * zfs create fs

 * zfs create [-s] -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;

	char *size = NULL;

	char *blocksize = NULL;

	int c;

	boolean_t noreserve = B_FALSE;

	int ret;

	/* check options */

	while ((c = getopt(argc, argv, ":V:b:s")) != -1) {

		switch (c) {

		case 'V':

			type = ZFS_TYPE_VOLUME;

			size = optarg;

			break;

		case 'b':

			blocksize = optarg;

			break;

		case 's':

			noreserve = B_TRUE;

			break;

		case ':':

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

			    "argument\n"));

			usage(B_FALSE);

			break;

		case '?':

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

			    optopt);

			usage(B_FALSE);

		}

	}

	if (noreserve && type != ZFS_TYPE_VOLUME) {

		(void) fprintf(stderr, gettext("'-s' can only be used when "

		    "creating a volume\n"));

		usage(B_FALSE);

	}

	argc -= optind;

	argv += optind;

	/* check number of arguments */

	if (argc == 0) {

		(void) fprintf(stderr, gettext("missing %s argument\n"),

		    zfs_type_to_name(type));

		usage(B_FALSE);

	}

	if (argc > 1) {

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

		usage(B_FALSE);

	}

	/* pass to libzfs */

	if (zfs_create(g_zfs, argv[0], type, size, blocksize) != 0)

		return (1);

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

		return (1);

	/*

	 * Volume handling.  By default, we try to create a reservation of equal

	 * size for the volume.  If we can't do this, then destroy the dataset

	 * and report an error.

	 */

	if (type == ZFS_TYPE_VOLUME && !noreserve) {

		if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, size) != 0) {

			(void) fprintf(stderr, gettext("use '-s' to create a "

			    "volume without a matching reservation\n"));

			(void) zfs_destroy(zhp);

			return (1);

		}

	}

	/*

	 * Mount and/or share the new filesystem as appropriate.  We provide a

	 * verbose error message to let the user know that their filesystem was

	 * in fact created, even if we failed to mount or share it.

	 */

	if (zfs_mount(zhp, NULL, 0) != 0) {

		(void) fprintf(stderr, gettext("filesystem successfully "

		    "created, but not mounted\n"));

		ret = 1;

	} else if (zfs_share(zhp) != 0) {

		(void) fprintf(stderr, gettext("filesystem successfully "

		    "created, but not shared\n"));

		ret = 1;

	} else {

		ret = 0;

	}

	zfs_close(zhp);

	return (ret);

}

/*

 * zfs destroy [-rf] <fs, snap, vol>

 *

 * 	-r	Recursively destroy all children

 * 	-R	Recursively destroy all dependents, including clones

 * 	-f	Force unmounting of any dependents

 *

 * Destroys the given dataset.  By default, it will unmount any filesystems,

 * and refuse to destroy a dataset that has any dependents.  A dependent can

 * either be a child, or a clone of a child.

 */

typedef struct destroy_cbdata {

	boolean_t	cb_first;

	int		cb_force;

	int		cb_recurse;

	int		cb_error;

	int		cb_needforce;

	int		cb_doclones;

	zfs_handle_t	*cb_target;

} destroy_cbdata_t;

/*

 * Check for any dependents based on the '-r' or '-R' flags.

 */

static int

destroy_check_dependent(zfs_handle_t *zhp, void *data)

{

	destroy_cbdata_t *cbp = data;

	const char *tname = zfs_get_name(cbp->cb_target);

	const char *name = zfs_get_name(zhp);