/*

 * 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 2008 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 <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <unistd.h>

#include <stddef.h>

#include <fcntl.h>

#include <sys/mount.h>

#include <sys/mntent.h>

#include <sys/mnttab.h>

#include <sys/avl.h>

#include <stddef.h>

#include <libzfs.h>

#include "zfs_namecheck.h"

#include "zfs_prop.h"

#include "libzfs_impl.h"

#include <fletcher.c> /* XXX */

/*

 * Routines for dealing with the AVL tree of fs-nvlists

 */

typedef struct fsavl_node {

	avl_node_t fn_node;

	nvlist_t *fn_nvfs;

	char *fn_snapname;

	uint64_t fn_guid;

} fsavl_node_t;

static int

fsavl_compare(const void *arg1, const void *arg2)

{

	const fsavl_node_t *fn1 = arg1;

	const fsavl_node_t *fn2 = arg2;

	if (fn1->fn_guid > fn2->fn_guid)

		return (+1);

	else if (fn1->fn_guid < fn2->fn_guid)

		return (-1);

	else

		return (0);

}

/*

 * Given the GUID of a snapshot, find its containing filesystem and

 * (optionally) name.

 */

static nvlist_t *

fsavl_find(avl_tree_t *avl, uint64_t snapguid, char **snapname)

{

	fsavl_node_t fn_find;

	fsavl_node_t *fn;

	fn_find.fn_guid = snapguid;

	fn = avl_find(avl, &fn_find, NULL);

	if (fn) {

		if (snapname)

			*snapname = fn->fn_snapname;

		return (fn->fn_nvfs);

	}

	return (NULL);

}

static void

fsavl_destroy(avl_tree_t *avl)

{

	fsavl_node_t *fn;

	void *cookie;

	if (avl == NULL)

		return;

	cookie = NULL;

	while ((fn = avl_destroy_nodes(avl, &cookie)) != NULL)

		free(fn);

	avl_destroy(avl);

	free(avl);

}

static avl_tree_t *

fsavl_create(nvlist_t *fss)

{

	avl_tree_t *fsavl;

	nvpair_t *fselem = NULL;

	if ((fsavl = malloc(sizeof (avl_tree_t))) == NULL)

		return (NULL);

	avl_create(fsavl, fsavl_compare, sizeof (fsavl_node_t),

	    offsetof(fsavl_node_t, fn_node));

	while ((fselem = nvlist_next_nvpair(fss, fselem)) != NULL) {

		nvlist_t *nvfs, *snaps;

		nvpair_t *snapelem = NULL;

		VERIFY(0 == nvpair_value_nvlist(fselem, &nvfs));

		VERIFY(0 == nvlist_lookup_nvlist(nvfs, "snaps", &snaps));

		while ((snapelem =

		    nvlist_next_nvpair(snaps, snapelem)) != NULL) {

			fsavl_node_t *fn;

			uint64_t guid;

			VERIFY(0 == nvpair_value_uint64(snapelem, &guid));

			if ((fn = malloc(sizeof (fsavl_node_t))) == NULL) {

				fsavl_destroy(fsavl);

				return (NULL);

			}

			fn->fn_nvfs = nvfs;

			fn->fn_snapname = nvpair_name(snapelem);

			fn->fn_guid = guid;

			/*

			 * Note: if there are multiple snaps with the

			 * same GUID, we ignore all but one.

			 */

			if (avl_find(fsavl, fn, NULL) == NULL)

				avl_add(fsavl, fn);

			else

				free(fn);

		}

	}

	return (fsavl);

}

/*

 * Routines for dealing with the giant nvlist of fs-nvlists, etc.

 */

typedef struct send_data {

	uint64_t parent_fromsnap_guid;

	nvlist_t *parent_snaps;

	nvlist_t *fss;

	nvlist_t *snapprops;

	const char *fromsnap;

	const char *tosnap;

	/*

	 * The header nvlist is of the following format:

	 * {

	 *   "tosnap" -> string

	 *   "fromsnap" -> string (if incremental)

	 *   "fss" -> {

	 *	id -> {

	 *

	 *	 "name" -> string (full name; for debugging)

	 *	 "parentfromsnap" -> number (guid of fromsnap in parent)

	 *

	 *	 "props" -> { name -> value (only if set here) }

	 *	 "snaps" -> { name (lastname) -> number (guid) }

	 *	 "snapprops" -> { name (lastname) -> { name -> value } }

	 *

	 *	 "origin" -> number (guid) (if clone)

	 *	 "sent" -> boolean (not on-disk)

	 *	}

	 *   }

	 * }

	 *

	 */

} send_data_t;

static void send_iterate_prop(zfs_handle_t *zhp, nvlist_t *nv);

static int

send_iterate_snap(zfs_handle_t *zhp, void *arg)

{

	send_data_t *sd = arg;

	uint64_t guid = zhp->zfs_dmustats.dds_guid;

	char *snapname;

	nvlist_t *nv;

	snapname = strrchr(zhp->zfs_name, '@')+1;

	VERIFY(0 == nvlist_add_uint64(sd->parent_snaps, snapname, guid));

	/*

	 * NB: if there is no fromsnap here (it's a newly created fs in

	 * an incremental replication), we will substitute the tosnap.

	 */

	if ((sd->fromsnap && strcmp(snapname, sd->fromsnap) == 0) ||

	    (sd->parent_fromsnap_guid == 0 && sd->tosnap &&

	    strcmp(snapname, sd->tosnap) == 0)) {

		sd->parent_fromsnap_guid = guid;

	}

	VERIFY(0 == nvlist_alloc(&nv, NV_UNIQUE_NAME, 0));

	send_iterate_prop(zhp, nv);

	VERIFY(0 == nvlist_add_nvlist(sd->snapprops, snapname, nv));

	nvlist_free(nv);

	zfs_close(zhp);

	return (0);

}

static void

send_iterate_prop(zfs_handle_t *zhp, nvlist_t *nv)

{

	nvpair_t *elem = NULL;

	while ((elem = nvlist_next_nvpair(zhp->zfs_props, elem)) != NULL) {

		char *propname = nvpair_name(elem);

		zfs_prop_t prop = zfs_name_to_prop(propname);

		nvlist_t *propnv;

		if (!zfs_prop_user(propname) && zfs_prop_readonly(prop))

			continue;

		verify(nvpair_value_nvlist(elem, &propnv) == 0);

		if (prop == ZFS_PROP_QUOTA || prop == ZFS_PROP_RESERVATION) {

			/* these guys are modifyable, but have no source */

			uint64_t value;

			verify(nvlist_lookup_uint64(propnv,

			    ZPROP_VALUE, &value) == 0);

			if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT)

				continue;

		} else {

			char *source;

			if (nvlist_lookup_string(propnv,

			    ZPROP_SOURCE, &source) != 0)

				continue;

			if (strcmp(source, zhp->zfs_name) != 0)

				continue;

		}

		if (zfs_prop_user(propname) ||

		    zfs_prop_get_type(prop) == PROP_TYPE_STRING) {

			char *value;

			verify(nvlist_lookup_string(propnv,

			    ZPROP_VALUE, &value) == 0);

			VERIFY(0 == nvlist_add_string(nv, propname, value));

		} else {

			uint64_t value;

			verify(nvlist_lookup_uint64(propnv,

			    ZPROP_VALUE, &value) == 0);

			VERIFY(0 == nvlist_add_uint64(nv, propname, value));

		}

	}

}

static int

send_iterate_fs(zfs_handle_t *zhp, void *arg)

{

	send_data_t *sd = arg;

	nvlist_t *nvfs, *nv;

	int rv;

	uint64_t parent_fromsnap_guid_save = sd->parent_fromsnap_guid;

	uint64_t guid = zhp->zfs_dmustats.dds_guid;

	char guidstring[64];

	VERIFY(0 == nvlist_alloc(&nvfs, NV_UNIQUE_NAME, 0));

	VERIFY(0 == nvlist_add_string(nvfs, "name", zhp->zfs_name));

	VERIFY(0 == nvlist_add_uint64(nvfs, "parentfromsnap",

	    sd->parent_fromsnap_guid));

	if (zhp->zfs_dmustats.dds_origin[0]) {

		zfs_handle_t *origin = zfs_open(zhp->zfs_hdl,

		    zhp->zfs_dmustats.dds_origin, ZFS_TYPE_SNAPSHOT);

		if (origin == NULL)

			return (-1);

		VERIFY(0 == nvlist_add_uint64(nvfs, "origin",

		    origin->zfs_dmustats.dds_guid));

	}

	/* iterate over props */

	VERIFY(0 == nvlist_alloc(&nv, NV_UNIQUE_NAME, 0));

	send_iterate_prop(zhp, nv);

	VERIFY(0 == nvlist_add_nvlist(nvfs, "props", nv));

	nvlist_free(nv);

	/* iterate over snaps, and set sd->parent_fromsnap_guid */

	sd->parent_fromsnap_guid = 0;

	VERIFY(0 == nvlist_alloc(&sd->parent_snaps, NV_UNIQUE_NAME, 0));

	VERIFY(0 == nvlist_alloc(&sd->snapprops, NV_UNIQUE_NAME, 0));

	(void) zfs_iter_snapshots(zhp, send_iterate_snap, sd);

	VERIFY(0 == nvlist_add_nvlist(nvfs, "snaps", sd->parent_snaps));

	VERIFY(0 == nvlist_add_nvlist(nvfs, "snapprops", sd->snapprops));

	nvlist_free(sd->parent_snaps);

	nvlist_free(sd->snapprops);

	/* add this fs to nvlist */

	(void) snprintf(guidstring, sizeof (guidstring),

	    "0x%llx", (longlong_t)guid);

	VERIFY(0 == nvlist_add_nvlist(sd->fss, guidstring, nvfs));

	nvlist_free(nvfs);

	/* iterate over children */

	rv = zfs_iter_filesystems(zhp, send_iterate_fs, sd);

	sd->parent_fromsnap_guid = parent_fromsnap_guid_save;

	zfs_close(zhp);

	return (rv);

}

static int

gather_nvlist(libzfs_handle_t *hdl, const char *fsname, const char *fromsnap,

    const char *tosnap, nvlist_t **nvlp, avl_tree_t **avlp)

{

	zfs_handle_t *zhp;

	send_data_t sd = { 0 };

	int error;

	zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);

	if (zhp == NULL)

		return (EZFS_BADTYPE);

	VERIFY(0 == nvlist_alloc(&sd.fss, NV_UNIQUE_NAME, 0));

	sd.fromsnap = fromsnap;

	sd.tosnap = tosnap;

	if ((error = send_iterate_fs(zhp, &sd)) != 0) {

		nvlist_free(sd.fss);

		if (avlp != NULL)

			*avlp = NULL;

		*nvlp = NULL;

		return (error);

	}

	if (avlp != NULL && (*avlp = fsavl_create(sd.fss)) == NULL) {

		nvlist_free(sd.fss);

		*nvlp = NULL;

		return (EZFS_NOMEM);

	}

	*nvlp = sd.fss;

	return (0);

}

/*

 * Routines for dealing with the sorted snapshot functionality

 */

typedef struct zfs_node {

	zfs_handle_t	*zn_handle;

	avl_node_t	zn_avlnode;

} zfs_node_t;

static int

zfs_sort_snaps(zfs_handle_t *zhp, void *data)

{

	avl_tree_t *avl = data;

	zfs_node_t *node = zfs_alloc(zhp->zfs_hdl, sizeof (zfs_node_t));

	node->zn_handle = zhp;

	avl_add(avl, node);

	return (0);

}

/* ARGSUSED */

static int

zfs_snapshot_compare(const void *larg, const void *rarg)

{

	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;

	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;

	uint64_t lcreate, rcreate;

	/*

	 * Sort them according to creation time.  We use the hidden

	 * CREATETXG property to get an absolute ordering of snapshots.

	 */

	lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);

	rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);

	if (lcreate < rcreate)

		return (-1);

	else if (lcreate > rcreate)

		return (+1);

	else

		return (0);

}

static int

zfs_iter_snapshots_sorted(zfs_handle_t *zhp, zfs_iter_f callback, void *data)

{

	int ret = 0;

	zfs_node_t *node;

	avl_tree_t avl;

	void *cookie = NULL;

	avl_create(&avl, zfs_snapshot_compare,

	    sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));

	ret = zfs_iter_snapshots(zhp, zfs_sort_snaps, &avl);

	for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))

		ret |= callback(node->zn_handle, data);

	while ((node = avl_destroy_nodes(&avl, &cookie)) != NULL)

		free(node);

	avl_destroy(&avl);

	return (ret);

}

/*

 * Routines specific to "zfs send"

 */

typedef struct send_dump_data {

	/* these are all just the short snapname (the part after the @) */

	const char *fromsnap;

	const char *tosnap;

	char lastsnap[ZFS_MAXNAMELEN];

	boolean_t seenfrom, seento, replicate, doall, fromorigin;

	boolean_t verbose;

	int outfd;

	boolean_t err;

	nvlist_t *fss;

	avl_tree_t *fsavl;

} send_dump_data_t;

/*

 * Dumps a backup of the given snapshot (incremental from fromsnap if it's not

 * NULL) to the file descriptor specified by outfd.

 */

static int

dump_ioctl(zfs_handle_t *zhp, const char *fromsnap, boolean_t fromorigin,

    int outfd)

{

	zfs_cmd_t zc = { 0 };

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);

	assert(fromsnap == NULL || fromsnap[0] == '\0' || !fromorigin);

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

	if (fromsnap)

		(void) strlcpy(zc.zc_value, fromsnap, sizeof (zc.zc_value));

	zc.zc_cookie = outfd;

	zc.zc_obj = fromorigin;

	if (ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SEND, &zc) != 0) {

		char errbuf[1024];

		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,

		    "warning: cannot send '%s'"), zhp->zfs_name);

		switch (errno) {

		case EXDEV:

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "not an earlier snapshot from the same fs"));

			return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));

		case ENOENT:

			if (zfs_dataset_exists(hdl, zc.zc_name,

			    ZFS_TYPE_SNAPSHOT)) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "incremental source (@%s) does not exist"),

				    zc.zc_value);

			}

			return (zfs_error(hdl, EZFS_NOENT, errbuf));

		case EDQUOT:

		case EFBIG:

		case EIO:

		case ENOLINK:

		case ENOSPC:

		case ENOSTR:

		case ENXIO:

		case EPIPE:

		case ERANGE:

		case EFAULT:

		case EROFS:

			zfs_error_aux(hdl, strerror(errno));

			return (zfs_error(hdl, EZFS_BADBACKUP, errbuf));

		default:

			return (zfs_standard_error(hdl, errno, errbuf));

		}

	}

	return (0);

}

static int

dump_snapshot(zfs_handle_t *zhp, void *arg)

{

	send_dump_data_t *sdd = arg;

	const char *thissnap;

	int err;

	thissnap = strchr(zhp->zfs_name, '@') + 1;

	if (sdd->fromsnap && !sdd->seenfrom &&

	    strcmp(sdd->fromsnap, thissnap) == 0) {

		sdd->seenfrom = B_TRUE;

		(void) strcpy(sdd->lastsnap, thissnap);

		zfs_close(zhp);

		return (0);

	}