/*

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

 */

/*

 * NFS specific functions

 */

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <stdlib.h>

#include <unistd.h>

#include <zone.h>

#include <errno.h>

#include <locale.h>

#include <signal.h>

#include "libshare.h"

#include "libshare_impl.h"

#include <nfs/export.h>

#include <pwd.h>

#include <limits.h>

#include <libscf.h>

#include "nfslog_config.h"

#include "nfslogtab.h"

#include "libshare_nfs.h"

#include <rpcsvc/daemon_utils.h>

#include <nfs/nfs.h>

#include <nfs/nfssys.h>

/* should really be in some global place */

#define	DEF_WIN	30000

#define	OPT_CHUNK	1024

int debug = 0;

#define	NFS_SERVER_SVC	"svc:/network/nfs/server:default"

/* internal functions */

static int nfs_init();

static void nfs_fini();

static int nfs_enable_share(sa_share_t);

static int nfs_disable_share(sa_share_t, char *);

static int nfs_validate_property(sa_handle_t, sa_property_t, sa_optionset_t);

static int nfs_validate_security_mode(char *);

static int nfs_is_security_opt(char *);

static int nfs_parse_legacy_options(sa_group_t, char *);

static char *nfs_format_options(sa_group_t, int);

static int nfs_set_proto_prop(sa_property_t);

static sa_protocol_properties_t nfs_get_proto_set();

static char *nfs_get_status();

static char *nfs_space_alias(char *);

static uint64_t nfs_features();

/*

 * ops vector that provides the protocol specific info and operations

 * for share management.

 */

struct sa_plugin_ops sa_plugin_ops = {

	SA_PLUGIN_VERSION,

	"nfs",

	nfs_init,

	nfs_fini,

	nfs_enable_share,

	nfs_disable_share,

	nfs_validate_property,

	nfs_validate_security_mode,

	nfs_is_security_opt,

	nfs_parse_legacy_options,

	nfs_format_options,

	nfs_set_proto_prop,

	nfs_get_proto_set,

	nfs_get_status,

	nfs_space_alias,

	NULL,	/* update_legacy */

	NULL,	/* delete_legacy */

	NULL,	/* change_notify */

	NULL,	/* enable_resource */

	NULL,	/* disable_resource */

	nfs_features,

	NULL,	/* transient shares */

	NULL,	/* notify resource */

	NULL,	/* rename_resource */

	NULL,	/* run_command */

	NULL,	/* command_help */

	NULL	/* delete_proto_section */

};

/*

 * list of support services needed

 * defines should come from head/rpcsvc/daemon_utils.h

 */

static char *service_list_default[] =

	{ STATD, LOCKD, MOUNTD, NFSD, NFSMAPID, RQUOTAD, NULL };

static char *service_list_logging[] =

	{ STATD, LOCKD, MOUNTD, NFSD, NFSMAPID, RQUOTAD, NFSLOGD, NULL };

/*

 * option definitions.  Make sure to keep the #define for the option

 * index just before the entry it is the index for. Changing the order

 * can cause breakage.  E.g OPT_RW is index 1 and must precede the

 * line that includes the SHOPT_RW and OPT_RW entries.

 */

struct option_defs optdefs[] = {

#define	OPT_RO		0

	{SHOPT_RO, OPT_RO, OPT_TYPE_ACCLIST},

#define	OPT_RW		1

	{SHOPT_RW, OPT_RW, OPT_TYPE_ACCLIST},

#define	OPT_ROOT	2

	{SHOPT_ROOT, OPT_ROOT, OPT_TYPE_ACCLIST},

#define	OPT_SECURE	3

	{SHOPT_SECURE, OPT_SECURE, OPT_TYPE_DEPRECATED},

#define	OPT_ANON	4

	{SHOPT_ANON, OPT_ANON, OPT_TYPE_USER},

#define	OPT_WINDOW	5

	{SHOPT_WINDOW, OPT_WINDOW, OPT_TYPE_NUMBER},

#define	OPT_NOSUID	6

	{SHOPT_NOSUID, OPT_NOSUID, OPT_TYPE_BOOLEAN},

#define	OPT_ACLOK	7

	{SHOPT_ACLOK, OPT_ACLOK, OPT_TYPE_BOOLEAN},

#define	OPT_NOSUB	8

	{SHOPT_NOSUB, OPT_NOSUB, OPT_TYPE_BOOLEAN},

#define	OPT_SEC		9

	{SHOPT_SEC, OPT_SEC, OPT_TYPE_SECURITY},

#define	OPT_PUBLIC	10

	{SHOPT_PUBLIC, OPT_PUBLIC, OPT_TYPE_BOOLEAN, OPT_SHARE_ONLY},

#define	OPT_INDEX	11

	{SHOPT_INDEX, OPT_INDEX, OPT_TYPE_FILE},

#define	OPT_LOG		12

	{SHOPT_LOG, OPT_LOG, OPT_TYPE_LOGTAG},

#define	OPT_CKSUM	13

	{SHOPT_CKSUM, OPT_CKSUM, OPT_TYPE_STRINGSET},

#ifdef VOLATILE_FH_TEST	/* XXX added for testing volatile fh's only */

	{SHOPT_VOLFH, OPT_VOLFH},

#endif /* VOLATILE_FH_TEST */

	NULL

};

/*

 * list of properties that are related to security flavors.

 */

static char *seclist[] = {

	SHOPT_RO,

	SHOPT_RW,

	SHOPT_ROOT,

	SHOPT_WINDOW,

	NULL

};

/* structure for list of securities */

struct securities {

	sa_security_t security;

	struct securities *next;

};

/*

 * findopt(name)

 *

 * Lookup option "name" in the option table and return the table

 * index.

 */

static int

findopt(char *name)

{

	int i;

	if (name != NULL) {

		for (i = 0; optdefs[i].tag != NULL; i++) {

			if (strcmp(optdefs[i].tag, name) == 0)

				return (i);

		}

	}

	return (-1);

}

/*

 * gettype(name)

 *

 * Return the type of option "name".

 */

static int

gettype(char *name)

{

	int optdef;

	optdef = findopt(name);

	if (optdef != -1)

		return (optdefs[optdef].type);

	return (OPT_TYPE_ANY);

}

/*

 * nfs_validate_security_mode(mode)

 *

 * is the specified mode string a valid one for use with NFS?

 */

static int

nfs_validate_security_mode(char *mode)

{

	seconfig_t secinfo;

	int err;

	(void) memset(&secinfo, '\0', sizeof (secinfo));

	err = nfs_getseconfig_byname(mode, &secinfo);

	if (err == SC_NOERROR)

		return (1);

	return (0);

}

/*

 * nfs_is_security_opt(tok)

 *

 * check to see if tok represents an option that is only valid in some

 * security flavor.

 */

static int

nfs_is_security_opt(char *tok)

{

	int i;

	for (i = 0; seclist[i] != NULL; i++) {

		if (strcmp(tok, seclist[i]) == 0)

			return (1);

	}

	return (0);

}

/*

 * find_security(seclist, sec)

 *

 * Walk the current list of security flavors and return true if it is

 * present, else return false.

 */

static int

find_security(struct securities *seclist, sa_security_t sec)

{

	while (seclist != NULL) {

		if (seclist->security == sec)

			return (1);

		seclist = seclist->next;

	}

	return (0);

}

/*

 * make_security_list(group, securitymodes, proto)

 *	go through the list of securitymodes and add them to the

 *	group's list of security optionsets. We also keep a list of

 *	those optionsets so we don't have to find them later. All of

 *	these will get copies of the same properties.

 */

static struct securities *

make_security_list(sa_group_t group, char *securitymodes, char *proto)

{

	char *tok, *next = NULL;

	struct securities *curp, *headp = NULL, *prev;

	sa_security_t check;

	int freetok = 0;

	for (tok = securitymodes; tok != NULL; tok = next) {

		next = strchr(tok, ':');

		if (next != NULL)

			*next++ = '\0';

		if (strcmp(tok, "default") == 0) {

			/* resolve default into the real type */

			tok = nfs_space_alias(tok);

			freetok = 1;

		}

		check = sa_get_security(group, tok, proto);

		/* add to the security list if it isn't there already */

		if (check == NULL || !find_security(headp, check)) {

			curp = (struct securities *)calloc(1,

			    sizeof (struct securities));

			if (curp != NULL) {

				if (check == NULL) {

					curp->security = sa_create_security(

					    group, tok, proto);

				} else {

					curp->security = check;

				}

				/*

				 * note that the first time through the loop,

				 * headp will be NULL and prev will be

				 * undefined.  Since headp is NULL, we set

				 * both it and prev to the curp (first

				 * structure to be allocated).

				 *

				 * later passes through the loop will have

				 * headp not being NULL and prev will be used

				 * to allocate at the end of the list.

				 */

				if (headp == NULL) {

					headp = curp;

					prev = curp;

				} else {

					prev->next = curp;

					prev = curp;

				}

			}

		}

		if (freetok) {

			freetok = 0;

			sa_free_attr_string(tok);

		}

	}

	return (headp);

}

static void

free_security_list(struct securities *sec)

{

	struct securities *next;

	if (sec != NULL) {

		for (next = sec->next; sec != NULL; sec = next) {

			next = sec->next;

			free(sec);

		}

	}

}

/*

 * nfs_alistcat(str1, str2, sep)

 *

 * concatenate str1 and str2 into a new string using sep as a separate

 * character. If memory allocation fails, return NULL;

 */

static char *

nfs_alistcat(char *str1, char *str2, char sep)

{

	char *newstr;

	size_t len;

	len = strlen(str1) + strlen(str2) + 2;

	newstr = (char *)malloc(len);

	if (newstr != NULL)

		(void) snprintf(newstr, len, "%s%c%s", str1, sep, str2);

	return (newstr);

}

/*

 * add_security_prop(sec, name, value, persist)

 *

 * Add the property to the securities structure. This accumulates

 * properties for as part of parsing legacy options.

 */

static int

add_security_prop(struct securities *sec, char *name, char *value,

			int persist, int iszfs)

{

	sa_property_t prop;

	int ret = SA_OK;

	for (; sec != NULL; sec = sec->next) {

		if (value == NULL) {

			if (strcmp(name, SHOPT_RW) == 0 ||

			    strcmp(name, SHOPT_RO) == 0)

				value = "*";

			else

				value = "true";

		}

		/*

		 * Get the existing property, if it exists, so we can

		 * determine what to do with it. The ro/rw/root

		 * properties can be merged if multiple instances of

		 * these properies are given. For example, if "rw"

		 * exists with a value "host1" and a later token of

		 * rw="host2" is seen, the values are merged into a

		 * single rw="host1:host2".

		 */

		prop = sa_get_property(sec->security, name);

		if (prop != NULL) {

			char *oldvalue;

			char *newvalue;

			/*

			 * The security options of ro/rw/root might appear

			 * multiple times. If they do, the values need to be

			 * merged into an access list. If it was previously

			 * empty, the new value alone is added.

			 */

			oldvalue = sa_get_property_attr(prop, "value");

			if (oldvalue != NULL) {

				/*

				 * The general case is to concatenate the new

				 * value onto the old value for multiple

				 * rw(ro/root) properties. A special case

				 * exists when either the old or new is the

				 * "all" case. In the special case, if both

				 * are "all", then it is "all", else if one is

				 * an access-list, that replaces the "all".

				 */

				if (strcmp(oldvalue, "*") == 0) {

					/* Replace old value with new value. */

					newvalue = strdup(value);

				} else if (strcmp(value, "*") == 0 ||

				    strcmp(oldvalue, value) == 0) {

					/*

					 * Keep old value and ignore

					 * the new value.

					 */

					newvalue = NULL;

				} else {

					/*

					 * Make a new list of old plus new

					 * access-list.

					 */

					newvalue = nfs_alistcat(oldvalue,

					    value, ':');

				}

				if (newvalue != NULL) {

					(void) sa_remove_property(prop);

					prop = sa_create_property(name,

					    newvalue);

					ret = sa_add_property(sec->security,

					    prop);

					free(newvalue);

				}