[mirror_zfs.git] / lib / libshare / os / linux / nfs.c

/*
 * 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 https://opensource.org/licenses/CDDL-1.0.
 * 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 (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2011 Gunnar Beutner
 * Copyright (c) 2012 Cyril Plisko. All rights reserved.
 * Copyright (c) 2019, 2022 by Delphix. All rights reserved.
 */

#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <libzfs.h>
#include <libshare.h>
#include "libshare_impl.h"
#include "nfs.h"

#define	ZFS_EXPORTS_DIR		"/etc/exports.d"
#define	ZFS_EXPORTS_FILE	ZFS_EXPORTS_DIR"/zfs.exports"
#define	ZFS_EXPORTS_LOCK	ZFS_EXPORTS_FILE".lock"


static boolean_t nfs_available(void);

typedef int (*nfs_shareopt_callback_t)(const char *opt, const char *value,
    void *cookie);

typedef int (*nfs_host_callback_t)(FILE *tmpfile, const char *sharepath,
    const char *host, const char *security, const char *access, void *cookie);

/*
 * Invokes the specified callback function for each Solaris share option
 * listed in the specified string.
 */
static int
foreach_nfs_shareopt(const char *shareopts,
    nfs_shareopt_callback_t callback, void *cookie)
{
	char *shareopts_dup, *opt, *cur, *value;
	int was_nul, error;

	if (shareopts == NULL)
		return (SA_OK);

	if (strcmp(shareopts, "on") == 0)
		shareopts = "rw,crossmnt";

	shareopts_dup = strdup(shareopts);


	if (shareopts_dup == NULL)
		return (SA_NO_MEMORY);

	opt = shareopts_dup;
	was_nul = 0;

	while (1) {
		cur = opt;

		while (*cur != ',' && *cur != '\0')
			cur++;

		if (*cur == '\0')
			was_nul = 1;

		*cur = '\0';

		if (cur > opt) {
			value = strchr(opt, '=');

			if (value != NULL) {
				*value = '\0';
				value++;
			}

			error = callback(opt, value, cookie);

			if (error != SA_OK) {
				free(shareopts_dup);
				return (error);
			}
		}

		opt = cur + 1;

		if (was_nul)
			break;
	}

	free(shareopts_dup);

	return (SA_OK);
}

typedef struct nfs_host_cookie_s {
	nfs_host_callback_t callback;
	const char *sharepath;
	void *cookie;
	FILE *tmpfile;
	const char *security;
} nfs_host_cookie_t;

/*
 * Helper function for foreach_nfs_host. This function checks whether the
 * current share option is a host specification and invokes a callback
 * function with information about the host.
 */
static int
foreach_nfs_host_cb(const char *opt, const char *value, void *pcookie)
{
	int error;
	const char *access;
	char *host_dup, *host, *next, *v6Literal;
	nfs_host_cookie_t *udata = (nfs_host_cookie_t *)pcookie;
	int cidr_len;

#ifdef DEBUG
	fprintf(stderr, "foreach_nfs_host_cb: key=%s, value=%s\n", opt, value);
#endif

	if (strcmp(opt, "sec") == 0)
		udata->security = value;

	if (strcmp(opt, "rw") == 0 || strcmp(opt, "ro") == 0) {
		if (value == NULL)
			value = "*";

		access = opt;

		host_dup = strdup(value);

		if (host_dup == NULL)
			return (SA_NO_MEMORY);

		host = host_dup;

		do {
			if (*host == '[') {
				host++;
				v6Literal = strchr(host, ']');
				if (v6Literal == NULL) {
					free(host_dup);
					return (SA_SYNTAX_ERR);
				}
				if (v6Literal[1] == '\0') {
					*v6Literal = '\0';
					next = NULL;
				} else if (v6Literal[1] == '/') {
					next = strchr(v6Literal + 2, ':');
					if (next == NULL) {
						cidr_len =
						    strlen(v6Literal + 1);
						memmove(v6Literal,
						    v6Literal + 1,
						    cidr_len);
						v6Literal[cidr_len] = '\0';
					} else {
						cidr_len = next - v6Literal - 1;
						memmove(v6Literal,
						    v6Literal + 1,
						    cidr_len);
						v6Literal[cidr_len] = '\0';
						next++;
					}
				} else if (v6Literal[1] == ':') {
					*v6Literal = '\0';
					next = v6Literal + 2;
				} else {
					free(host_dup);
					return (SA_SYNTAX_ERR);
				}
			} else {
				next = strchr(host, ':');
				if (next != NULL) {
					*next = '\0';
					next++;
				}
			}

			error = udata->callback(udata->tmpfile,
			    udata->sharepath, host, udata->security,
			    access, udata->cookie);

			if (error != SA_OK) {
				free(host_dup);

				return (error);
			}

			host = next;
		} while (host != NULL);

		free(host_dup);
	}

	return (SA_OK);
}

/*
 * Invokes a callback function for all NFS hosts that are set for a share.
 */
static int
foreach_nfs_host(sa_share_impl_t impl_share, FILE *tmpfile,
    nfs_host_callback_t callback, void *cookie)
{
	nfs_host_cookie_t udata;

	udata.callback = callback;
	udata.sharepath = impl_share->sa_mountpoint;
	udata.cookie = cookie;
	udata.tmpfile = tmpfile;
	udata.security = "sys";

	return (foreach_nfs_shareopt(impl_share->sa_shareopts,
	    foreach_nfs_host_cb, &udata));
}

/*
 * Converts a Solaris NFS host specification to its Linux equivalent.
 */
static const char *
get_linux_hostspec(const char *solaris_hostspec)
{
	/*
	 * For now we just support CIDR masks (e.g. @192.168.0.0/16) and host
	 * wildcards (e.g. *.example.org).
	 */
	if (solaris_hostspec[0] == '@') {
		/*
		 * Solaris host specifier, e.g. @192.168.0.0/16; we just need
		 * to skip the @ in this case
		 */
		return (solaris_hostspec + 1);
	} else {
		return (solaris_hostspec);
	}
}

/*
 * Adds a Linux share option to an array of NFS options.
 */
static int
add_linux_shareopt(char **plinux_opts, const char *key, const char *value)
{
	size_t len = 0;
	char *new_linux_opts;

	if (*plinux_opts != NULL)
		len = strlen(*plinux_opts);

	new_linux_opts = realloc(*plinux_opts, len + 1 + strlen(key) +
	    (value ? 1 + strlen(value) : 0) + 1);

	if (new_linux_opts == NULL)
		return (SA_NO_MEMORY);

	new_linux_opts[len] = '\0';

	if (len > 0)
		strcat(new_linux_opts, ",");

	strcat(new_linux_opts, key);

	if (value != NULL) {
		strcat(new_linux_opts, "=");
		strcat(new_linux_opts, value);
	}

	*plinux_opts = new_linux_opts;

	return (SA_OK);
}

static int string_cmp(const void *lhs, const void *rhs) {
	const char *const *l = lhs, *const *r = rhs;
	return (strcmp(*l, *r));
}

/*
 * Validates and converts a single Solaris share option to its Linux
 * equivalent.
 */
static int
get_linux_shareopts_cb(const char *key, const char *value, void *cookie)
{
	/* This list must remain sorted, since we bsearch() it */
	static const char *const valid_keys[] = { "all_squash", "anongid",
	    "anonuid", "async", "auth_nlm", "crossmnt", "fsid", "fsuid", "hide",
	    "insecure", "insecure_locks", "mountpoint", "mp", "no_acl",
	    "no_all_squash", "no_auth_nlm", "no_root_squash",
	    "no_subtree_check", "no_wdelay", "nohide", "refer", "replicas",
	    "root_squash", "secure", "secure_locks", "subtree_check", "sync",
	    "wdelay" };

	char **plinux_opts = (char **)cookie;

	/* host-specific options, these are taken care of elsewhere */
	if (strcmp(key, "ro") == 0 || strcmp(key, "rw") == 0 ||
	    strcmp(key, "sec") == 0)
		return (SA_OK);

	if (strcmp(key, "anon") == 0)
		key = "anonuid";

	if (strcmp(key, "root_mapping") == 0) {
		(void) add_linux_shareopt(plinux_opts, "root_squash", NULL);
		key = "anonuid";
	}

	if (strcmp(key, "nosub") == 0)
		key = "subtree_check";

	if (bsearch(&key, valid_keys, ARRAY_SIZE(valid_keys),
	    sizeof (*valid_keys), string_cmp) == NULL)
		return (SA_SYNTAX_ERR);

	(void) add_linux_shareopt(plinux_opts, key, value);

	return (SA_OK);
}

/*
 * Takes a string containing Solaris share options (e.g. "sync,no_acl") and
 * converts them to a NULL-terminated array of Linux NFS options.
 */
static int
get_linux_shareopts(const char *shareopts, char **plinux_opts)
{
	int error;

	assert(plinux_opts != NULL);

	*plinux_opts = NULL;

	/* no_subtree_check - Default as of nfs-utils v1.1.0 */
	(void) add_linux_shareopt(plinux_opts, "no_subtree_check", NULL);

	/* mountpoint - Restrict exports to ZFS mountpoints */
	(void) add_linux_shareopt(plinux_opts, "mountpoint", NULL);

	error = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb,
	    plinux_opts);

	if (error != SA_OK) {
		free(*plinux_opts);
		*plinux_opts = NULL;
	}

	return (error);
}

/*
 * This function populates an entry into /etc/exports.d/zfs.exports.
 * This file is consumed by the linux nfs server so that zfs shares are
 * automatically exported upon boot or whenever the nfs server restarts.
 */
static int
nfs_add_entry(FILE *tmpfile, const char *sharepath,
    const char *host, const char *security, const char *access_opts,
    void *pcookie)
{
	const char *linux_opts = (const char *)pcookie;

	if (linux_opts == NULL)
		linux_opts = "";

	boolean_t need_free;
	char *mp;
	int rc = nfs_escape_mountpoint(sharepath, &mp, &need_free);
	if (rc != SA_OK)
		return (rc);
	if (fprintf(tmpfile, "%s %s(sec=%s,%s,%s)\n", mp,
	    get_linux_hostspec(host), security, access_opts,
	    linux_opts) < 0) {
		fprintf(stderr, "failed to write to temporary file\n");
		rc = SA_SYSTEM_ERR;
	}

	if (need_free)
		free(mp);
	return (rc);
}

/*
 * Enables NFS sharing for the specified share.
 */
static int
nfs_enable_share_impl(sa_share_impl_t impl_share, FILE *tmpfile)
{
	char *linux_opts = NULL;
	int error = get_linux_shareopts(impl_share->sa_shareopts, &linux_opts);
	if (error != SA_OK)
		return (error);

	error = foreach_nfs_host(impl_share, tmpfile, nfs_add_entry,
	    linux_opts);
	free(linux_opts);
	return (error);
}

static int
nfs_enable_share(sa_share_impl_t impl_share)
{
	if (!nfs_available())
		return (SA_SYSTEM_ERR);

	return (nfs_toggle_share(
	    ZFS_EXPORTS_LOCK, ZFS_EXPORTS_FILE, ZFS_EXPORTS_DIR, impl_share,
	    nfs_enable_share_impl));
}

/*
 * Disables NFS sharing for the specified share.
 */
static int
nfs_disable_share_impl(sa_share_impl_t impl_share, FILE *tmpfile)
{
	(void) impl_share, (void) tmpfile;
	return (SA_OK);
}

static int
nfs_disable_share(sa_share_impl_t impl_share)
{
	if (!nfs_available())
		return (SA_SYSTEM_ERR);

	return (nfs_toggle_share(
	    ZFS_EXPORTS_LOCK, ZFS_EXPORTS_FILE, ZFS_EXPORTS_DIR, impl_share,
	    nfs_disable_share_impl));
}

static boolean_t
nfs_is_shared(sa_share_impl_t impl_share)
{
	if (!nfs_available())
		return (SA_SYSTEM_ERR);

	return (nfs_is_shared_impl(ZFS_EXPORTS_FILE, impl_share));
}

/*
 * Checks whether the specified NFS share options are syntactically correct.
 */
static int
nfs_validate_shareopts(const char *shareopts)
{
	char *linux_opts = NULL;
	int error = get_linux_shareopts(shareopts, &linux_opts);
	if (error != SA_OK)
		return (error);

	free(linux_opts);
	return (SA_OK);
}

static int
nfs_commit_shares(void)
{
	if (!nfs_available())
		return (SA_SYSTEM_ERR);

	char *argv[] = {
	    (char *)"/usr/sbin/exportfs",
	    (char *)"-ra",
	    NULL
	};

	return (libzfs_run_process(argv[0], argv, 0));
}

static void
nfs_truncate_shares(void)
{
	nfs_reset_shares(ZFS_EXPORTS_LOCK, ZFS_EXPORTS_FILE);
}

const sa_fstype_t libshare_nfs_type = {
	.enable_share = nfs_enable_share,
	.disable_share = nfs_disable_share,
	.is_shared = nfs_is_shared,

	.validate_shareopts = nfs_validate_shareopts,
	.commit_shares = nfs_commit_shares,
	.truncate_shares = nfs_truncate_shares,
};

static boolean_t
nfs_available(void)
{
	static int avail;

	if (!avail) {
		if (access("/usr/sbin/exportfs", F_OK) != 0)
			avail = -1;
		else
			avail = 1;
	}

	return (avail == 1);
}
Commit	Line	Data
	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License (the "License").
	6	* You may not use this file except in compliance with the License.
	7	*
	8	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
	9	* or https://opensource.org/licenses/CDDL-1.0.
	10	* See the License for the specific language governing permissions
	11	* and limitations under the License.
	12	*
	13	* When distributing Covered Code, include this CDDL HEADER in each
	14	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	15	* If applicable, add the following below this CDDL HEADER, with the
	16	* fields enclosed by brackets "[]" replaced with your own identifying
	17	* information: Portions Copyright [yyyy] [name of copyright owner]
	18	*
	19	* CDDL HEADER END
	20	*/
	21
	22	/*
	23	* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
	24	* Copyright (c) 2011 Gunnar Beutner
	25	* Copyright (c) 2012 Cyril Plisko. All rights reserved.
	26	* Copyright (c) 2019, 2022 by Delphix. All rights reserved.
	27	*/
	28
	29	#include <dirent.h>
	30	#include <stdio.h>
	31	#include <string.h>
	32	#include <errno.h>
	33	#include <fcntl.h>
	34	#include <sys/file.h>
	35	#include <sys/stat.h>
	36	#include <sys/types.h>
	37	#include <sys/wait.h>
	38	#include <unistd.h>
	39	#include <libzfs.h>
	40	#include <libshare.h>
	41	#include "libshare_impl.h"
	42	#include "nfs.h"
	43
	44	#define ZFS_EXPORTS_DIR "/etc/exports.d"
	45	#define ZFS_EXPORTS_FILE ZFS_EXPORTS_DIR"/zfs.exports"
	46	#define ZFS_EXPORTS_LOCK ZFS_EXPORTS_FILE".lock"
	47
	48
	49	static boolean_t nfs_available(void);
	50
	51	typedef int (nfs_shareopt_callback_t)(const char opt, const char *value,
	52	void *cookie);
	53
	54	typedef int (nfs_host_callback_t)(FILE tmpfile, const char *sharepath,
	55	const char host, const char security, const char access, void cookie);
	56
	57	/*
	58	* Invokes the specified callback function for each Solaris share option
	59	* listed in the specified string.
	60	*/
	61	static int
	62	foreach_nfs_shareopt(const char *shareopts,
	63	nfs_shareopt_callback_t callback, void *cookie)
	64	{
	65	char shareopts_dup, opt, cur, value;
	66	int was_nul, error;
	67
	68	if (shareopts == NULL)
	69	return (SA_OK);
	70
	71	if (strcmp(shareopts, "on") == 0)
	72	shareopts = "rw,crossmnt";
	73
	74	shareopts_dup = strdup(shareopts);
	75
	76
	77	if (shareopts_dup == NULL)
	78	return (SA_NO_MEMORY);
	79
	80	opt = shareopts_dup;
	81	was_nul = 0;
	82
	83	while (1) {
	84	cur = opt;
	85
	86	while (cur != ',' && cur != '\0')
	87	cur++;
	88
	89	if (*cur == '\0')
	90	was_nul = 1;
	91
	92	*cur = '\0';
	93
	94	if (cur > opt) {
	95	value = strchr(opt, '=');
	96
	97	if (value != NULL) {
	98	*value = '\0';
	99	value++;
	100	}
	101
	102	error = callback(opt, value, cookie);
	103
	104	if (error != SA_OK) {
	105	free(shareopts_dup);
	106	return (error);
	107	}
	108	}
	109
	110	opt = cur + 1;
	111
	112	if (was_nul)
	113	break;
	114	}
	115
	116	free(shareopts_dup);
	117
	118	return (SA_OK);
	119	}
	120
	121	typedef struct nfs_host_cookie_s {
	122	nfs_host_callback_t callback;
	123	const char *sharepath;
	124	void *cookie;
	125	FILE *tmpfile;
	126	const char *security;
	127	} nfs_host_cookie_t;
	128
	129	/*
	130	* Helper function for foreach_nfs_host. This function checks whether the
	131	* current share option is a host specification and invokes a callback
	132	* function with information about the host.
	133	*/
	134	static int
	135	foreach_nfs_host_cb(const char opt, const char value, void *pcookie)
	136	{
	137	int error;
	138	const char *access;
	139	char host_dup, host, next, v6Literal;
	140	nfs_host_cookie_t udata = (nfs_host_cookie_t )pcookie;
	141	int cidr_len;
	142
	143	#ifdef DEBUG
	144	fprintf(stderr, "foreach_nfs_host_cb: key=%s, value=%s\n", opt, value);
	145	#endif
	146
	147	if (strcmp(opt, "sec") == 0)
	148	udata->security = value;
	149
	150	if (strcmp(opt, "rw") == 0 \|\| strcmp(opt, "ro") == 0) {
	151	if (value == NULL)
	152	value = "*";
	153
	154	access = opt;
	155
	156	host_dup = strdup(value);
	157
	158	if (host_dup == NULL)
	159	return (SA_NO_MEMORY);
	160
	161	host = host_dup;
	162
	163	do {
	164	if (*host == '[') {
	165	host++;
	166	v6Literal = strchr(host, ']');
	167	if (v6Literal == NULL) {
	168	free(host_dup);
	169	return (SA_SYNTAX_ERR);
	170	}
	171	if (v6Literal[1] == '\0') {
	172	*v6Literal = '\0';
	173	next = NULL;
	174	} else if (v6Literal[1] == '/') {
	175	next = strchr(v6Literal + 2, ':');
	176	if (next == NULL) {
	177	cidr_len =
	178	strlen(v6Literal + 1);
	179	memmove(v6Literal,
	180	v6Literal + 1,
	181	cidr_len);
	182	v6Literal[cidr_len] = '\0';
	183	} else {
	184	cidr_len = next - v6Literal - 1;
	185	memmove(v6Literal,
	186	v6Literal + 1,
	187	cidr_len);
	188	v6Literal[cidr_len] = '\0';
	189	next++;
	190	}
	191	} else if (v6Literal[1] == ':') {
	192	*v6Literal = '\0';
	193	next = v6Literal + 2;
	194	} else {
	195	free(host_dup);
	196	return (SA_SYNTAX_ERR);
	197	}
	198	} else {
	199	next = strchr(host, ':');
	200	if (next != NULL) {
	201	*next = '\0';
	202	next++;
	203	}
	204	}
	205
	206	error = udata->callback(udata->tmpfile,
	207	udata->sharepath, host, udata->security,
	208	access, udata->cookie);
	209
	210	if (error != SA_OK) {
	211	free(host_dup);
	212
	213	return (error);
	214	}
	215
	216	host = next;
	217	} while (host != NULL);
	218
	219	free(host_dup);
	220	}
	221
	222	return (SA_OK);
	223	}
	224
	225	/*
	226	* Invokes a callback function for all NFS hosts that are set for a share.
	227	*/
	228	static int
	229	foreach_nfs_host(sa_share_impl_t impl_share, FILE *tmpfile,
	230	nfs_host_callback_t callback, void *cookie)
	231	{
	232	nfs_host_cookie_t udata;
	233
	234	udata.callback = callback;
	235	udata.sharepath = impl_share->sa_mountpoint;
	236	udata.cookie = cookie;
	237	udata.tmpfile = tmpfile;
	238	udata.security = "sys";
	239
	240	return (foreach_nfs_shareopt(impl_share->sa_shareopts,
	241	foreach_nfs_host_cb, &udata));
	242	}
	243
	244	/*
	245	* Converts a Solaris NFS host specification to its Linux equivalent.
	246	*/
	247	static const char *
	248	get_linux_hostspec(const char *solaris_hostspec)
	249	{
	250	/*
	251	* For now we just support CIDR masks (e.g. @192.168.0.0/16) and host
	252	* wildcards (e.g. *.example.org).
	253	*/
	254	if (solaris_hostspec[0] == '@') {
	255	/*
	256	* Solaris host specifier, e.g. @192.168.0.0/16; we just need
	257	* to skip the @ in this case
	258	*/
	259	return (solaris_hostspec + 1);
	260	} else {
	261	return (solaris_hostspec);
	262	}
	263	}
	264
	265	/*
	266	* Adds a Linux share option to an array of NFS options.
	267	*/
	268	static int
	269	add_linux_shareopt(char *plinux_opts, const char key, const char *value)
	270	{
	271	size_t len = 0;
	272	char *new_linux_opts;
	273
	274	if (*plinux_opts != NULL)
	275	len = strlen(*plinux_opts);
	276
	277	new_linux_opts = realloc(*plinux_opts, len + 1 + strlen(key) +
	278	(value ? 1 + strlen(value) : 0) + 1);
	279
	280	if (new_linux_opts == NULL)
	281	return (SA_NO_MEMORY);
	282
	283	new_linux_opts[len] = '\0';
	284
	285	if (len > 0)
	286	strcat(new_linux_opts, ",");
	287
	288	strcat(new_linux_opts, key);
	289
	290	if (value != NULL) {
	291	strcat(new_linux_opts, "=");
	292	strcat(new_linux_opts, value);
	293	}
	294
	295	*plinux_opts = new_linux_opts;
	296
	297	return (SA_OK);
	298	}
	299
	300	static int string_cmp(const void lhs, const void rhs) {
	301	const char const l = lhs, const r = rhs;
	302	return (strcmp(l, r));
	303	}
	304
	305	/*
	306	* Validates and converts a single Solaris share option to its Linux
	307	* equivalent.
	308	*/
	309	static int
	310	get_linux_shareopts_cb(const char key, const char value, void *cookie)
	311	{
	312	/* This list must remain sorted, since we bsearch() it */
	313	static const char *const valid_keys[] = { "all_squash", "anongid",
	314	"anonuid", "async", "auth_nlm", "crossmnt", "fsid", "fsuid", "hide",
	315	"insecure", "insecure_locks", "mountpoint", "mp", "no_acl",
	316	"no_all_squash", "no_auth_nlm", "no_root_squash",
	317	"no_subtree_check", "no_wdelay", "nohide", "refer", "replicas",
	318	"root_squash", "secure", "secure_locks", "subtree_check", "sync",
	319	"wdelay" };
	320
	321	char plinux_opts = (char )cookie;
	322
	323	/* host-specific options, these are taken care of elsewhere */
	324	if (strcmp(key, "ro") == 0 \|\| strcmp(key, "rw") == 0 \|\|
	325	strcmp(key, "sec") == 0)
	326	return (SA_OK);
	327
	328	if (strcmp(key, "anon") == 0)
	329	key = "anonuid";
	330
	331	if (strcmp(key, "root_mapping") == 0) {
	332	(void) add_linux_shareopt(plinux_opts, "root_squash", NULL);
	333	key = "anonuid";
	334	}
	335
	336	if (strcmp(key, "nosub") == 0)
	337	key = "subtree_check";
	338
	339	if (bsearch(&key, valid_keys, ARRAY_SIZE(valid_keys),
	340	sizeof (*valid_keys), string_cmp) == NULL)
	341	return (SA_SYNTAX_ERR);
	342
	343	(void) add_linux_shareopt(plinux_opts, key, value);
	344
	345	return (SA_OK);
	346	}
	347
	348	/*
	349	* Takes a string containing Solaris share options (e.g. "sync,no_acl") and
	350	* converts them to a NULL-terminated array of Linux NFS options.
	351	*/
	352	static int
	353	get_linux_shareopts(const char shareopts, char *plinux_opts)
	354	{
	355	int error;
	356
	357	assert(plinux_opts != NULL);
	358
	359	*plinux_opts = NULL;
	360
	361	/* no_subtree_check - Default as of nfs-utils v1.1.0 */
	362	(void) add_linux_shareopt(plinux_opts, "no_subtree_check", NULL);
	363
	364	/* mountpoint - Restrict exports to ZFS mountpoints */
	365	(void) add_linux_shareopt(plinux_opts, "mountpoint", NULL);
	366
	367	error = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb,
	368	plinux_opts);
	369
	370	if (error != SA_OK) {
	371	free(*plinux_opts);
	372	*plinux_opts = NULL;
	373	}
	374
	375	return (error);
	376	}
	377
	378	/*
	379	* This function populates an entry into /etc/exports.d/zfs.exports.
	380	* This file is consumed by the linux nfs server so that zfs shares are
	381	* automatically exported upon boot or whenever the nfs server restarts.
	382	*/
	383	static int
	384	nfs_add_entry(FILE tmpfile, const char sharepath,
	385	const char host, const char security, const char *access_opts,
	386	void *pcookie)
	387	{
	388	const char linux_opts = (const char )pcookie;
	389
	390	if (linux_opts == NULL)
	391	linux_opts = "";
	392
	393	boolean_t need_free;
	394	char *mp;
	395	int rc = nfs_escape_mountpoint(sharepath, &mp, &need_free);
	396	if (rc != SA_OK)
	397	return (rc);
	398	if (fprintf(tmpfile, "%s %s(sec=%s,%s,%s)\n", mp,
	399	get_linux_hostspec(host), security, access_opts,
	400	linux_opts) < 0) {
	401	fprintf(stderr, "failed to write to temporary file\n");
	402	rc = SA_SYSTEM_ERR;
	403	}
	404
	405	if (need_free)
	406	free(mp);
	407	return (rc);
	408	}
	409
	410	/*
	411	* Enables NFS sharing for the specified share.
	412	*/
	413	static int
	414	nfs_enable_share_impl(sa_share_impl_t impl_share, FILE *tmpfile)
	415	{
	416	char *linux_opts = NULL;
	417	int error = get_linux_shareopts(impl_share->sa_shareopts, &linux_opts);
	418	if (error != SA_OK)
	419	return (error);
	420
	421	error = foreach_nfs_host(impl_share, tmpfile, nfs_add_entry,
	422	linux_opts);
	423	free(linux_opts);
	424	return (error);
	425	}
	426
	427	static int
	428	nfs_enable_share(sa_share_impl_t impl_share)
	429	{
	430	if (!nfs_available())
	431	return (SA_SYSTEM_ERR);
	432
	433	return (nfs_toggle_share(
	434	ZFS_EXPORTS_LOCK, ZFS_EXPORTS_FILE, ZFS_EXPORTS_DIR, impl_share,
	435	nfs_enable_share_impl));
	436	}
	437
	438	/*
	439	* Disables NFS sharing for the specified share.
	440	*/
	441	static int
	442	nfs_disable_share_impl(sa_share_impl_t impl_share, FILE *tmpfile)
	443	{
	444	(void) impl_share, (void) tmpfile;
	445	return (SA_OK);
	446	}
	447
	448	static int
	449	nfs_disable_share(sa_share_impl_t impl_share)
	450	{
	451	if (!nfs_available())
	452	return (SA_SYSTEM_ERR);
	453
	454	return (nfs_toggle_share(
	455	ZFS_EXPORTS_LOCK, ZFS_EXPORTS_FILE, ZFS_EXPORTS_DIR, impl_share,
	456	nfs_disable_share_impl));
	457	}
	458
	459	static boolean_t
	460	nfs_is_shared(sa_share_impl_t impl_share)
	461	{
	462	if (!nfs_available())
	463	return (SA_SYSTEM_ERR);
	464
	465	return (nfs_is_shared_impl(ZFS_EXPORTS_FILE, impl_share));
	466	}
	467
	468	/*
	469	* Checks whether the specified NFS share options are syntactically correct.
	470	*/
	471	static int
	472	nfs_validate_shareopts(const char *shareopts)
	473	{
	474	char *linux_opts = NULL;
	475	int error = get_linux_shareopts(shareopts, &linux_opts);
	476	if (error != SA_OK)
	477	return (error);
	478
	479	free(linux_opts);
	480	return (SA_OK);
	481	}
	482
	483	static int
	484	nfs_commit_shares(void)
	485	{
	486	if (!nfs_available())
	487	return (SA_SYSTEM_ERR);
	488
	489	char *argv[] = {
	490	(char *)"/usr/sbin/exportfs",
	491	(char *)"-ra",
	492	NULL
	493	};
	494
	495	return (libzfs_run_process(argv[0], argv, 0));
	496	}
	497
	498	static void
	499	nfs_truncate_shares(void)
	500	{
	501	nfs_reset_shares(ZFS_EXPORTS_LOCK, ZFS_EXPORTS_FILE);
	502	}
	503
	504	const sa_fstype_t libshare_nfs_type = {
	505	.enable_share = nfs_enable_share,
	506	.disable_share = nfs_disable_share,
	507	.is_shared = nfs_is_shared,
	508
	509	.validate_shareopts = nfs_validate_shareopts,
	510	.commit_shares = nfs_commit_shares,
	511	.truncate_shares = nfs_truncate_shares,
	512	};
	513
	514	static boolean_t
	515	nfs_available(void)
	516	{
	517	static int avail;
	518
	519	if (!avail) {
	520	if (access("/usr/sbin/exportfs", F_OK) != 0)
	521	avail = -1;
	522	else
	523	avail = 1;
	524	}
	525
	526	return (avail == 1);
	527	}