/*

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

 */

/*

 * Routines to manage ZFS mounts.  We separate all the nasty routines that have

 * to deal with the OS.  The following functions are the main entry points --

 * they are used by mount and unmount and when changing a filesystem's

 * mountpoint.

 *

 * 	zfs_is_mounted()

 * 	zfs_mount()

 * 	zfs_unmount()

 * 	zfs_unmountall()

 *

 * This file also contains the functions used to manage sharing filesystems via

 * NFS and iSCSI:

 *

 * 	zfs_is_shared()

 * 	zfs_share()

 * 	zfs_unshare()

 *

 * 	zfs_is_shared_nfs()

 * 	zfs_is_shared_smb()

 * 	zfs_is_shared_iscsi()

 * 	zfs_share_proto()

 * 	zfs_shareall();

 * 	zfs_share_iscsi()

 * 	zfs_unshare_nfs()

 * 	zfs_unshare_smb()

 * 	zfs_unshareall_nfs()

 *	zfs_unshareall_smb()

 *	zfs_unshareall()

 *	zfs_unshareall_bypath()

 * 	zfs_unshare_iscsi()

 *

 * The following functions are available for pool consumers, and will

 * mount/unmount and share/unshare all datasets within pool:

 *

 * 	zpool_enable_datasets()

 * 	zpool_disable_datasets()

 */

#include <dirent.h>

#include <dlfcn.h>

#include <errno.h>

#include <libgen.h>

#include <libintl.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/stat.h>

#include <libzfs.h>

#include "libzfs_impl.h"

#include <libshare.h>

#include <sys/systeminfo.h>

#define	MAXISALEN	257	/* based on sysinfo(2) man page */

static int zfs_share_proto(zfs_handle_t *, zfs_share_proto_t *);

zfs_share_type_t zfs_is_shared_proto(zfs_handle_t *, char **,

    zfs_share_proto_t);

static int (*iscsitgt_zfs_share)(const char *);

static int (*iscsitgt_zfs_unshare)(const char *);

static int (*iscsitgt_zfs_is_shared)(const char *);

static int (*iscsitgt_svc_online)();

/*

 * The share protocols table must be in the same order as the zfs_share_prot_t

 * enum in libzfs_impl.h

 */

typedef struct {

	zfs_prop_t p_prop;

	char *p_name;

	int p_share_err;

	int p_unshare_err;

} proto_table_t;

proto_table_t proto_table[PROTO_END] = {

	{ZFS_PROP_SHARENFS, "nfs", EZFS_SHARENFSFAILED, EZFS_UNSHARENFSFAILED},

	{ZFS_PROP_SHARESMB, "smb", EZFS_SHARESMBFAILED, EZFS_UNSHARESMBFAILED},

};

zfs_share_proto_t nfs_only[] = {

	PROTO_NFS,

	PROTO_END

};

zfs_share_proto_t smb_only[] = {

	PROTO_SMB,

	PROTO_END

};

zfs_share_proto_t share_all_proto[] = {

	PROTO_NFS,

	PROTO_SMB,

	PROTO_END

};

#pragma init(zfs_iscsi_init)

static void

zfs_iscsi_init(void)

{

	void *libiscsitgt;

	if ((libiscsitgt = dlopen("/lib/libiscsitgt.so.1",

	    RTLD_LAZY | RTLD_GLOBAL)) == NULL ||

	    (iscsitgt_zfs_share = (int (*)(const char *))dlsym(libiscsitgt,

	    "iscsitgt_zfs_share")) == NULL ||

	    (iscsitgt_zfs_unshare = (int (*)(const char *))dlsym(libiscsitgt,

	    "iscsitgt_zfs_unshare")) == NULL ||

	    (iscsitgt_zfs_is_shared = (int (*)(const char *))dlsym(libiscsitgt,

	    "iscsitgt_zfs_is_shared")) == NULL ||

	    (iscsitgt_svc_online = (int (*)(const char *))dlsym(libiscsitgt,

	    "iscsitgt_svc_online")) == NULL) {

		iscsitgt_zfs_share = NULL;

		iscsitgt_zfs_unshare = NULL;

		iscsitgt_zfs_is_shared = NULL;

		iscsitgt_svc_online = NULL;

	}

}

/*

 * Search the sharetab for the given mountpoint and protocol, returning

 * a zfs_share_type_t value.

 */

static zfs_share_type_t

is_shared(libzfs_handle_t *hdl, const char *mountpoint, zfs_share_proto_t proto)

{

	char buf[MAXPATHLEN], *tab;

	char *ptr;

	if (hdl->libzfs_sharetab == NULL)

		return (SHARED_NOT_SHARED);

	(void) fseek(hdl->libzfs_sharetab, 0, SEEK_SET);

	while (fgets(buf, sizeof (buf), hdl->libzfs_sharetab) != NULL) {

		/* the mountpoint is the first entry on each line */

		if ((tab = strchr(buf, '\t')) == NULL)

			continue;

		*tab = '\0';

		if (strcmp(buf, mountpoint) == 0) {

			/*

			 * the protocol field is the third field

			 * skip over second field

			 */

			ptr = ++tab;

			if ((tab = strchr(ptr, '\t')) == NULL)

				continue;

			ptr = ++tab;

			if ((tab = strchr(ptr, '\t')) == NULL)

				continue;

			*tab = '\0';

			if (strcmp(ptr,

			    proto_table[proto].p_name) == 0) {

				switch (proto) {

				case PROTO_NFS:

					return (SHARED_NFS);

				case PROTO_SMB:

					return (SHARED_SMB);

				default:

					return (0);

				}

			}

		}

	}

	return (SHARED_NOT_SHARED);

}

/*

 * Returns true if the specified directory is empty.  If we can't open the

 * directory at all, return true so that the mount can fail with a more

 * informative error message.

 */

static boolean_t

dir_is_empty(const char *dirname)

{

	DIR *dirp;

	struct dirent64 *dp;

	if ((dirp = opendir(dirname)) == NULL)

		return (B_TRUE);

	while ((dp = readdir64(dirp)) != NULL) {

		if (strcmp(dp->d_name, ".") == 0 ||

		    strcmp(dp->d_name, "..") == 0)

			continue;

		(void) closedir(dirp);

		return (B_FALSE);

	}

	(void) closedir(dirp);

	return (B_TRUE);

}

/*

 * Checks to see if the mount is active.  If the filesystem is mounted, we fill

 * in 'where' with the current mountpoint, and return 1.  Otherwise, we return

 * 0.

 */

boolean_t

is_mounted(libzfs_handle_t *zfs_hdl, const char *special, char **where)

{

	struct mnttab search = { 0 }, entry;

	/*

	 * Search for the entry in /etc/mnttab.  We don't bother getting the

	 * mountpoint, as we can just search for the special device.  This will

	 * also let us find mounts when the mountpoint is 'legacy'.

	 */

	search.mnt_special = (char *)special;

	search.mnt_fstype = MNTTYPE_ZFS;

	rewind(zfs_hdl->libzfs_mnttab);

	if (getmntany(zfs_hdl->libzfs_mnttab, &entry, &search) != 0)

		return (B_FALSE);

	if (where != NULL)

		*where = zfs_strdup(zfs_hdl, entry.mnt_mountp);

	return (B_TRUE);

}

boolean_t

zfs_is_mounted(zfs_handle_t *zhp, char **where)

{

	return (is_mounted(zhp->zfs_hdl, zfs_get_name(zhp), where));

}

/*

 * Returns true if the given dataset is mountable, false otherwise.  Returns the

 * mountpoint in 'buf'.

 */

static boolean_t

zfs_is_mountable(zfs_handle_t *zhp, char *buf, size_t buflen,

    zprop_source_t *source)

{

	char sourceloc[ZFS_MAXNAMELEN];

	zprop_source_t sourcetype;

	if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type))

		return (B_FALSE);

	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen,

	    &sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0);

	if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 ||

	    strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0)

		return (B_FALSE);

	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_OFF)

		return (B_FALSE);

	if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) &&

	    getzoneid() == GLOBAL_ZONEID)

		return (B_FALSE);

	if (source)

		*source = sourcetype;

	return (B_TRUE);

}

/*

 * Mount the given filesystem.

 */

int

zfs_mount(zfs_handle_t *zhp, const char *options, int flags)

{

	struct stat buf;

	char mountpoint[ZFS_MAXPROPLEN];

	char mntopts[MNT_LINE_MAX];

	libzfs_handle_t *hdl = zhp->zfs_hdl;

	if (options == NULL)

		mntopts[0] = '\0';

	else

		(void) strlcpy(mntopts, options, sizeof (mntopts));

	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))

		return (0);

	/* Create the directory if it doesn't already exist */

	if (lstat(mountpoint, &buf) != 0) {

		if (mkdirp(mountpoint, 0755) != 0) {

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "failed to create mountpoint"));

			return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,

			    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),

			    mountpoint));

		}

	}

	/*

	 * Determine if the mountpoint is empty.  If so, refuse to perform the

	 * mount.  We don't perform this check if MS_OVERLAY is specified, which

	 * would defeat the point.  We also avoid this check if 'remount' is

	 * specified.

	 */

	if ((flags & MS_OVERLAY) == 0 &&

	    strstr(mntopts, MNTOPT_REMOUNT) == NULL &&

	    !dir_is_empty(mountpoint)) {

		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

		    "directory is not empty"));

		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,

		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));

	}

	/* perform the mount */

	if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,

	    MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {

		/*

		 * Generic errors are nasty, but there are just way too many

		 * from mount(), and they're well-understood.  We pick a few

		 * common ones to improve upon.

		 */

		if (errno == EBUSY) {

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "mountpoint or dataset is busy"));

		} else if (errno == EPERM) {

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "Insufficient privileges"));

		} else {

			zfs_error_aux(hdl, strerror(errno));

		}

		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,

		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),

		    zhp->zfs_name));

	}

	return (0);

}

/*

 * Unmount a single filesystem.

 */

static int

unmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags)

{

	if (umount2(mountpoint, flags) != 0) {

		zfs_error_aux(hdl, strerror(errno));

		return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,

		    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),

		    mountpoint));

	}

	return (0);

}

/*

 * Unmount the given filesystem.

 */

int

zfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags)

{

	struct mnttab search = { 0 }, entry;

	char *mntpt = NULL;

	/* check to see if need to unmount the filesystem */

	search.mnt_special = zhp->zfs_name;

	search.mnt_fstype = MNTTYPE_ZFS;

	rewind(zhp->zfs_hdl->libzfs_mnttab);

	if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&

	    getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, &search) == 0)) {

		/*

		 * mountpoint may have come from a call to

		 * getmnt/getmntany if it isn't NULL. If it is NULL,

		 * we know it comes from getmntany which can then get

		 * overwritten later. We strdup it to play it safe.

		 */

		if (mountpoint == NULL)

			mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);

		else

			mntpt = zfs_strdup(zhp->zfs_hdl, mountpoint);

		/*

		 * Unshare and unmount the filesystem

		 */

		if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0)

			return (-1);

		if (unmount_one(zhp->zfs_hdl, mntpt, flags) != 0) {

			free(mntpt);

			(void) zfs_shareall(zhp);

			return (-1);

		}

		free(mntpt);

	}

	return (0);

}

/*

 * Unmount this filesystem and any children inheriting the mountpoint property.

 * To do this, just act like we're changing the mountpoint property, but don't

 * remount the filesystems afterwards.

 */

int

zfs_unmountall(zfs_handle_t *zhp, int flags)

{

	prop_changelist_t *clp;

	int ret;

	clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, 0, flags);

	if (clp == NULL)

		return (-1);

	ret = changelist_prefix(clp);

	changelist_free(clp);

	return (ret);

}

boolean_t

zfs_is_shared(zfs_handle_t *zhp)

{

	zfs_share_type_t rc = 0;

	zfs_share_proto_t *curr_proto;

	if (ZFS_IS_VOLUME(zhp))

		return (zfs_is_shared_iscsi(zhp));

	for (curr_proto = share_all_proto; *curr_proto != PROTO_END;

	    curr_proto++)

		rc |= zfs_is_shared_proto(zhp, NULL, *curr_proto);

	return (rc ? B_TRUE : B_FALSE);

}

int

zfs_share(zfs_handle_t *zhp)

{

	if (ZFS_IS_VOLUME(zhp))

		return (zfs_share_iscsi(zhp));

	return (zfs_share_proto(zhp, share_all_proto));

}

int

zfs_unshare(zfs_handle_t *zhp)

{

	if (ZFS_IS_VOLUME(zhp))

		return (zfs_unshare_iscsi(zhp));

	return (zfs_unshareall(zhp));

}

/*

 * Check to see if the filesystem is currently shared.

 */

zfs_share_type_t

zfs_is_shared_proto(zfs_handle_t *zhp, char **where, zfs_share_proto_t proto)

{

	char *mountpoint;

	zfs_share_type_t rc;

	if (!zfs_is_mounted(zhp, &mountpoint))

		return (SHARED_NOT_SHARED);

	if (rc = is_shared(zhp->zfs_hdl, mountpoint, proto)) {

		if (where != NULL)