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

/*
 * SMB 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 <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <syslog.h>
#include "libshare.h"
#include "libshare_impl.h"
#include <pwd.h>
#include <limits.h>
#include <libscf.h>
#include <strings.h>
#include "libshare_smbfs.h"
#include <rpcsvc/daemon_utils.h>
#include <arpa/inet.h>
#include <uuid/uuid.h>
#include <netsmb/smb_lib.h>

#define	SMBFS_PROTOCOL_NAME	"smbfs"

/* internal functions */
static uint64_t smbfs_features();
static int smbfs_init();
static void smbfs_fini();
static int smbfs_set_proto_prop(sa_property_t);
static sa_protocol_properties_t smbfs_get_proto_set();
static char *smbfs_get_status();
static int smbfs_delete_section(char *);
static int smbfs_delete_property_group(char *);

static int range_check_validator(int, char *, char *);
static int string_length_check_validator(int, char *, char *);
static int yes_no_validator(int, char *, char *);
static int ip_address_validator(int, char *, char *);
static int minauth_validator(int, char *, char *);
static int password_validator(int, char *, char *);
static int signing_validator(int, char *, char *);

int propset_changed = 0;

/*
 * ops vector that provides the protocol specific info and operations
 * for share management.
 */

struct sa_plugin_ops sa_plugin_ops = {
	SA_PLUGIN_VERSION,
	SMBFS_PROTOCOL_NAME,
	smbfs_init,
	smbfs_fini,
	NULL,	/* share */
	NULL,	/* unshare */
	NULL,	/* valid_prop */
	NULL,	/* valid_space */
	NULL,	/* security_prop */
	NULL,	/* legacy_opts */
	NULL,	/* legacy_format */
	smbfs_set_proto_prop,
	smbfs_get_proto_set,
	smbfs_get_status,
	NULL,	/* space_alias */
	NULL,	/* update_legacy */
	NULL,	/* delete_legacy */
	NULL,	/* change_notify */
	NULL,	/* enable_resource */
	NULL,	/* disable_resource */
	smbfs_features,
	NULL,	/* get_transient_shares */
	NULL,	/* notify_resource */
	NULL,	/* rename_resource */
	NULL,	/* run_command */
	NULL,	/* command_help */
	smbfs_delete_section,
};

/*
 * is_a_number(number)
 *
 * is the string a number in one of the forms we want to use?
 */

static int
is_a_number(char *number)
{
	int ret = 1;
	int hex = 0;

	if (strncmp(number, "0x", 2) == 0) {
		number += 2;
		hex = 1;
	} else if (*number == '-') {
		number++; /* skip the minus */
	}

	while (ret == 1 && *number != '\0') {
		if (hex) {
			ret = isxdigit(*number++);
		} else {
			ret = isdigit(*number++);
		}
	}
	return (ret);
}

/*
 * Protocol management functions
 *
 * properties defined in the default files are defined in
 * proto_option_defs for parsing and validation.
 */

struct smbclnt_proto_option_defs smbclnt_proto_options[] = {
	{ "section", NULL, PROTO_OPT_SECTION,
	    0, 0, MAX_VALUE_BUFLEN,
	    string_length_check_validator},
	{ "addr", NULL, PROTO_OPT_ADDR,
	    0, 0, MAX_VALUE_BUFLEN,
	    ip_address_validator},
	{ "minauth", NULL, PROTO_OPT_MINAUTH,
	    0, 0, MAX_VALUE_BUFLEN,
	    minauth_validator},
	{ "nbns_broadcast", NULL, PROTO_OPT_NBNS_BROADCAST,
	    0, 0, 0,
	    yes_no_validator},
	{ "nbns_enable", NULL, PROTO_OPT_NBNS_ENABLE,
	    0, 0, 0,
	    yes_no_validator},
	{ "nbns", NULL, PROTO_OPT_NBNSADDR,
	    0, 0, MAX_VALUE_BUFLEN,
	    ip_address_validator},
	{ "password", NULL, PROTO_OPT_PASSWORD,
	    0, 0, MAX_VALUE_BUFLEN,
	    password_validator},
	{ "timeout", NULL, PROTO_OPT_TIMEOUT,
	    0, 0, 60,
	    range_check_validator},
	{ "user", NULL, PROTO_OPT_USER,
	    0, 0, MAX_VALUE_BUFLEN,
	    string_length_check_validator},
	{ "domain", NULL, PROTO_OPT_DOMAIN,
	    0, 0, MAX_VALUE_BUFLEN,
	    string_length_check_validator},
	{ "workgroup", NULL, PROTO_OPT_WORKGROUP,
	    0, 0, MAX_VALUE_BUFLEN,
	    string_length_check_validator},
	{ "signing", NULL, PROTO_OPT_SIGNING,
	    0, 0, MAX_VALUE_BUFLEN,
	    signing_validator},
	{NULL}
};

/*
 * Check the range of value as int range.
 */
/*ARGSUSED*/
static int
range_check_validator(int index, char *section, char *value)
{
	int ret = SA_OK;

	if (value == NULL)
		return (SA_BAD_VALUE);
	if (strlen(value) == 0)
		return (SA_OK);
	if (!is_a_number(value)) {
		ret = SA_BAD_VALUE;
	} else {
		int val;
		val = strtoul(value, NULL, 0);
		if (val < smbclnt_proto_options[index].minval ||
		    val > smbclnt_proto_options[index].maxval)
			ret = SA_BAD_VALUE;
	}
	return (ret);
}

/*
 * Check the length of the string
 */
/*ARGSUSED*/
static int
string_length_check_validator(int index, char *section, char *value)
{
	int ret = SA_OK;

	if (value == NULL)
		return (SA_BAD_VALUE);
	if (strlen(value) == 0)
		return (SA_OK);
	if (strlen(value) > smbclnt_proto_options[index].maxval)
		ret = SA_BAD_VALUE;
	return (ret);
}

/*
 * Check yes/no
 */
/*ARGSUSED*/
static int
yes_no_validator(int index, char *section, char *value)
{
	if (value == NULL)
		return (SA_BAD_VALUE);
	if (strlen(value) == 0)
		return (SA_OK);
	if ((strcasecmp(value, "yes") == 0) ||
	    (strcasecmp(value, "no") == 0) ||
	    (strcasecmp(value, "true") == 0) ||
	    (strcasecmp(value, "false") == 0))
		return (SA_OK);
	return (SA_BAD_VALUE);
}

/*
 * Check IP address.
 */
/*ARGSUSED*/
static int
ip_address_validator(int index, char *section, char *value)
{
	int len;

	if (value == NULL)
		return (SA_BAD_VALUE);
	len = strlen(value);
	if (len == 0)
		return (SA_OK);
	if (len > MAX_VALUE_BUFLEN)
		return (SA_BAD_VALUE);
	return (SA_OK);
}

/*ARGSUSED*/
static int
minauth_validator(int index, char *section, char *value)
{
	if (value == NULL)
		return (SA_BAD_VALUE);
	if (strlen(value) == 0)
		return (SA_OK);
	if (strcmp(value, "kerberos") == 0 ||
	    strcmp(value, "ntlmv2") == 0 ||
	    strcmp(value, "ntlm") == 0 ||
	    strcmp(value, "lm") == 0 ||
	    strcmp(value, "none") == 0)
		return (SA_OK);
	else
		return (SA_BAD_VALUE);
}

/*ARGSUSED*/
static int
signing_validator(int index, char *section, char *value)
{
	if (value == NULL)
		return (SA_BAD_VALUE);
	if (strlen(value) == 0)
		return (SA_OK);
	if (strcmp(value, "disabled") == 0 ||
	    strcmp(value, "enabled") == 0 ||
	    strcmp(value, "required") == 0)
		return (SA_OK);
	else
		return (SA_BAD_VALUE);
}

/*ARGSUSED*/
static int
password_validator(int index, char *section, char *value)
{
	char buffer[100];

	/* mangled passwords will start with this pattern */
	if (strlen(value) == 0)
		return (SA_OK);
	if (strncmp(value, "$$1", 3) != 0)
		return (SA_PASSWORD_ENC);
	if (smb_simpledecrypt(buffer, value) != 0)
		return (SA_BAD_VALUE);
	return (SA_OK);
}


/*
 * the protoset holds the defined options so we don't have to read
 * them multiple times
 */
sa_protocol_properties_t protoset;

static int
findprotoopt(char *name)
{
	int i;
	for (i = 0; smbclnt_proto_options[i].name != NULL; i++) {
		if (strcasecmp(smbclnt_proto_options[i].name, name) == 0)
			return (i);
	}
	return (-1);
}

/*
 * Load the persistent settings from SMF.  Each section is an SMF
 * property group with an "S-" prefix and a UUID, and the section
 * is itself a property which can have a more flexible name than
 * a property group name can have.  The section name need not be
 * the first property, so we have to be a little flexible, but
 * the change of name of the property groups is a reliable way
 * to know that we're seeing a different section.
 */
int
smbclnt_config_load()
{
	scf_simple_app_props_t *props = NULL;
	scf_simple_prop_t *prop = NULL, *lastprop = NULL;
	char *lastpgname = NULL, *pgname = NULL;
	char *name = NULL, *value = NULL;
	sa_property_t sect, node;

	props = scf_simple_app_props_get(NULL, SMBC_DEFAULT_INSTANCE_FMRI);
	if (props == NULL)
		return (-1);

	for (;;) {
		lastprop = prop;
		prop = (scf_simple_prop_t *)
		    scf_simple_app_props_next(props, lastprop);
		if (prop == NULL)
			break;

		/* Ignore properties that don't have our prefix */
		pgname = scf_simple_prop_pgname(prop);
		if (strncmp("S-", pgname, 2) != 0)
			continue;

		/*
		 * Note property group name changes, which mark sections
		 *
		 * The memory allocated by sa_create_section is
		 * linked into the list of children under protoset,
		 * and will eventually be freed via that list.
		 */
		if (lastpgname == NULL || strcmp(lastpgname, pgname) != 0) {
			sect = sa_create_section(NULL, pgname+2);
			(void) xmlSetProp(sect, (xmlChar *)"type",
			    (xmlChar *)SMBFS_PROTOCOL_NAME);
			(void) sa_add_protocol_property(protoset, sect);
			if (lastpgname)
				free(lastpgname);
			lastpgname = strdup(pgname);
		}
		name = scf_simple_prop_name(prop);
		value = scf_simple_prop_next_astring(prop);

		/* If we get a section name, apply it and consume it */
		if (strncmp("section", name, 7) == 0 && value != NULL) {
			(void) xmlSetProp(sect, (xmlChar *)"name",
			    (xmlChar *)value);
			continue;
		}

		/*
		 * We have an ordinary property.  Add to the section.
		 *
		 * The memory allocated by sa_create_property is
		 * linked into the list of children under "sect",
		 * and will eventually be freed via that list.
		 */
		node = sa_create_property(name, value);
		(void) sa_add_protocol_property(sect, node);
	}
	scf_simple_app_props_free(props);

	if (lastpgname)
		free(lastpgname);
	return (0);
}

/*
 * Save the set of properties for a particular section, which is
 * stored as a single property group.  Properties will have been
 * changed earlier by one or more calls to smbfs_save_property(),
 * which only set the value in our array and marked them as
 * SMBC_MODIFIED.
 */
int
smbfs_save_propset()
{
	smb_scfhandle_t *handle = NULL;
	char propgroup[256];
	char *section = smbclnt_proto_options[PROTO_OPT_SECTION].value;
	char *uu = NULL;
	uuid_t uuid;
	int i, ret = 0;
	sa_property_t propset;
	int new = 0, nonnull = 0;

	propset = sa_get_protocol_section(protoset, section);
	(void) strlcpy(propgroup, SMBC_PG_PREFIX, sizeof (propgroup));
	propgroup[SMBC_PG_PREFIX_LEN] = '\0';
	uu = sa_get_property_attr(propset, "extra");
	if (uu != NULL) {
		(void) strlcat(propgroup, uu, sizeof (propgroup));
		free(uu);
	} else {
		new = 1;
		smbclnt_proto_options[PROTO_OPT_SECTION].flags |= SMBC_MODIFIED;
		uuid_generate(uuid);
		uuid_unparse(uuid, &propgroup[SMBC_PG_PREFIX_LEN]);
	}

	handle = smb_smf_scf_init(SMBC_FMRI_PREFIX);
	if (handle == NULL) {
		return (1);
	}

	if ((ret = smb_smf_instance_create(handle, SMBC_FMRI_PREFIX,
	    SMBC_PG_INSTANCE)) != SMBC_SMF_OK) {
		goto out;
	}

	if ((ret = smb_smf_create_instance_pgroup(handle, propgroup))
	    != SMBC_SMF_OK) {
		goto out;
	}

	if ((ret = smb_smf_start_transaction(handle)) != SMBC_SMF_OK) {
		goto out;
	}

	for (i = PROTO_OPT_SECTION+1; i <= SMBC_OPT_MAX; i++) {
		if ((smbclnt_proto_options[i].flags & SMBC_MODIFIED) == 0)
			continue;
		if (strcmp(smbclnt_proto_options[i].value, "") == 0)
			ret = smb_smf_delete_property(handle,
			    smbclnt_proto_options[i].name);
		else {
			ret = smb_smf_set_string_property(handle,
			    smbclnt_proto_options[i].name,
			    smbclnt_proto_options[i].value);
			nonnull = 1;
		}
		free(smbclnt_proto_options[i].value);
		smbclnt_proto_options[i].value = NULL;
		smbclnt_proto_options[i].flags &= ~SMBC_MODIFIED;
		if (ret != SMBC_SMF_OK)
			goto outtrans;
	}
	/*
	 * Suppress new, null entries by not saving the section name.
	 */
	if (!new || nonnull) {
		ret = smb_smf_set_string_property(handle,
		    smbclnt_proto_options[PROTO_OPT_SECTION].name,
		    smbclnt_proto_options[PROTO_OPT_SECTION].value);
		free(smbclnt_proto_options[PROTO_OPT_SECTION].value);
		smbclnt_proto_options[PROTO_OPT_SECTION].value = NULL;
		smbclnt_proto_options[PROTO_OPT_SECTION].flags &=
		    ~SMBC_MODIFIED;
	}
	propset_changed = 0;

outtrans:
	ret = smb_smf_end_transaction(handle);
out:
	smb_smf_scf_fini(handle);
	return (ret);
}

/*
 * initprotofromdefault()
 *
 * read the default file(s) and add the defined values to the
 * protoset.  Note that default values are known from the built in
 * table in case the file doesn't have a definition.
 */

static int
initprotofromdefault()
{
	protoset = sa_create_protocol_properties(SMBFS_PROTOCOL_NAME);
	if (protoset == NULL)
		return (SA_NO_MEMORY);
	if (smbclnt_config_load() != 0)
		return (SA_OK);

	return (SA_OK);
}

/*
 *
 * smbfs_features()
 *
 * Report the plugin's features
 */
static uint64_t
smbfs_features()
{
	return (SA_FEATURE_HAS_SECTIONS | SA_FEATURE_ADD_PROPERTIES);
}

/*
 * smbfs_init()
 *
 * Initialize the smb plugin.
 */

static int
smbfs_init()
{
	int ret = SA_OK;

	if (sa_plugin_ops.sa_init != smbfs_init) {
		return (SA_SYSTEM_ERR);
	}

	if (initprotofromdefault() != SA_OK) {
		return (SA_SYSTEM_ERR);
	}

	return (ret);
}

/*
 * smbfs_fini()
 *
 * uninitialize the smb plugin. Want to avoid memory leaks.
 */

static void
smbfs_fini()
{
	if (propset_changed)
		(void) smbfs_save_propset();
	xmlFreeNode(protoset);
	protoset = NULL;
}

/*
 * smbfs_get_proto_set()
 *
 * Return an optionset with all the protocol specific properties in
 * it.
 */

static sa_protocol_properties_t
smbfs_get_proto_set()
{
	return (protoset);
}

/*
 * smbfs_validate_proto_prop(index, name, value)
 *
 * Verify that the property specifed by name can take the new
 * value. This is a sanity check to prevent bad values getting into
 * the default files.
 */
static int
smbfs_validate_proto_prop(int index, char *section, char *name, char *value)
{
	if ((section == NULL) || (name == NULL) || (index < 0))
		return (SA_BAD_VALUE);

	if (smbclnt_proto_options[index].validator == NULL)
		return (SA_OK);

	return (smbclnt_proto_options[index].validator(index, section, value));
}

/*
 * Save a property to our array; it will be stored to SMF later by
 * smbfs_save_propset().
 */
int
smbfs_save_property(int index, char *section, char *value)
{
	char *s;

	if (index == PROTO_OPT_WORKGROUP) {
		index = PROTO_OPT_DOMAIN;
	}
	propset_changed = 1;
	s = strdup(section);
	if (s == NULL)
		return (-1);
	smbclnt_proto_options[PROTO_OPT_SECTION].value = s;
	s = strdup(value);
	if (s == NULL)
		return (-1);
	smbclnt_proto_options[index].value = s;
	smbclnt_proto_options[index].flags |= SMBC_MODIFIED;
	return (0);
}

/*
 * smbfs_set_proto_prop(prop)
 *
 * check that prop is valid.
 */
/*ARGSUSED*/
static int
smbfs_set_proto_prop(sa_property_t prop)
{
	int ret = SA_OK;
	char *name;
	char *value;
	char *section;
	int i = -1;

	section = sa_get_property_attr(prop, "section");
	if (section == NULL)
		return (SA_NO_SECTION);
	name = sa_get_property_attr(prop, "type");
	value = sa_get_property_attr(prop, "value");
	if (name != NULL && value != NULL) {
		i = findprotoopt(name);
		if (i >= 0) {
			ret = smbfs_validate_proto_prop(i, section,
			    name, value);
			if (ret == SA_OK) {
				if (smbfs_save_property(i, section,
				    value) != 0) {
					ret = SA_SYSTEM_ERR;
					errno = EIO;
				}
			}
		} else
			ret = SA_INVALID_NAME;
	}
	if (name != NULL)
		sa_free_attr_string(name);
	if (value != NULL)
		sa_free_attr_string(value);
	if (section != NULL)
		sa_free_attr_string(section);

	return (ret);
}

/*
 * smbfs_get_status()
 *
 * What is the current status of the smbd? We use the SMF state here.
 * Caller must free the returned value.
 */

static char *
smbfs_get_status()
{
	return (smf_get_state(SMBC_DEFAULT_INSTANCE_FMRI));
}

/*
 * Delete a section by its name, which we will have read into an
 * XML optionset above.  We need to find it and find its UUID to
 * be able to generate the property group name in order to call
 * smbfs_delete_property_group().
 */
static int
smbfs_delete_section(char *section)
{
	char propgroup[256];
	char *uu = NULL;
	sa_property_t propset;
	int ret = SA_SYSTEM_ERR;

	propset = sa_get_protocol_section(protoset, section);
	(void) strlcpy(propgroup, SMBC_PG_PREFIX, sizeof (propgroup));
	propgroup[SMBC_PG_PREFIX_LEN] = '\0';
	uu = sa_get_property_attr(propset, "extra");
	if (uu == NULL)
		goto out;
	(void) strlcat(propgroup, uu, sizeof (propgroup));
	free(uu);
	if ((ret = smbfs_delete_property_group(propgroup)) != SMBC_SMF_OK)
		goto out;
	ret = SA_OK;
out:
	return (ret);
}

/*
 * Delete a property group by its name.  Called to do a 'delsect'
 * or called when smbclnt_config_load() notices an empty section
 * at the end of the properties.
 */
static int
smbfs_delete_property_group(char *propgroup)
{
	smb_scfhandle_t *handle = NULL;
	int ret = SA_SYSTEM_ERR;

	handle = smb_smf_scf_init(SMBC_FMRI_PREFIX);
	if (handle == NULL)
		goto out;

	if ((ret = smb_smf_instance_create(handle, SMBC_FMRI_PREFIX,
	    SMBC_PG_INSTANCE)) != SMBC_SMF_OK)
		goto out;

	if ((ret = smb_smf_delete_instance_pgroup(handle, propgroup))
	    != SMBC_SMF_OK)
		goto out;
	ret = SA_OK;
out:
	smb_smf_scf_fini(handle);
	return (ret);
}