/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * AUTOMOUNT 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 <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 <libdlpi.h>
#include "smfcfg.h"


static int autofs_init();
static void autofs_fini();
static int autofs_validate_property(sa_handle_t, sa_property_t, sa_optionset_t);
static int autofs_set_proto_prop(sa_property_t);
static sa_protocol_properties_t autofs_get_proto_set();
static char *autofs_get_status();
static uint64_t autofs_features();

static int initautofsprotofromsmf();
static int true_false_validator(int index, char *value);
static int strlen_validator(int index, char *value);
static int range_check_validator(int index, char *value);

/*
 * ops vector that provides the protocol specific info and operations
 * for share management.
 */
struct sa_plugin_ops sa_plugin_ops = {
        SA_PLUGIN_VERSION,
        "autofs",
        autofs_init,            /* Init autofs */
        autofs_fini,            /* Fini autofs */
        NULL,                   /* Start Sharing */
        NULL,                   /* stop sharing */
        autofs_validate_property,
        NULL,                   /* valid_space */
        NULL,                   /* security_prop */
        NULL,                   /* parse optstring */
        NULL,                   /* format optstring */
        autofs_set_proto_prop,  /* Set properties */
        autofs_get_proto_set,   /* get properties */
        autofs_get_status,      /* get status */
        NULL,                   /* space_alias */
        NULL,                   /* update_legacy */
        NULL,                   /* delete_legacy */
        NULL,                   /* change notify */
        NULL,                   /* enable resource */
        NULL,                   /* disable resource */
        autofs_features,        /* features */
        NULL,                   /* transient shares */
        NULL,                   /* notify resource */
        NULL,                   /* rename resource */
        NULL,                   /* run_command */
        NULL,                   /* command_help */
        NULL                    /* delete_proto_section */
};


static sa_protocol_properties_t protoset;

#define AUTOMOUNT_VERBOSE_DEFAULT       0
#define AUTOMOUNTD_VERBOSE_DEFAULT      0
#define AUTOMOUNT_NOBROWSE_DEFAULT      0
#define AUTOMOUNT_TIMEOUT_DEFAULT       600
#define AUTOMOUNT_TRACE_DEFAULT         0
/*
 * Protocol Management functions
 */
struct proto_option_defs {
        char *tag;
        char *name;     /* display name -- remove protocol identifier */
        int index;
        scf_type_t type;
        union {
            int intval;
            char *string;
        } defvalue;
        int32_t minval;
        int32_t maxval;
        int (*check)(int, char *);
} proto_options[] = {
#define PROTO_OPT_AUTOMOUNT_TIMEOUT     0
        { "timeout",
            "timeout",  PROTO_OPT_AUTOMOUNT_TIMEOUT,
            SCF_TYPE_INTEGER, AUTOMOUNT_TIMEOUT_DEFAULT,
            1, INT32_MAX, range_check_validator},
#define PROTO_OPT_AUTOMOUNT_VERBOSE     1
        { "automount_verbose",
            "automount_verbose", PROTO_OPT_AUTOMOUNT_VERBOSE,
            SCF_TYPE_BOOLEAN, AUTOMOUNT_VERBOSE_DEFAULT, 0, 1,
            true_false_validator},
#define PROTO_OPT_AUTOMOUNTD_VERBOSE    2
        { "automountd_verbose",
            "automountd_verbose", PROTO_OPT_AUTOMOUNTD_VERBOSE,
            SCF_TYPE_BOOLEAN, AUTOMOUNTD_VERBOSE_DEFAULT, 0, 1,
            true_false_validator},
#define PROTO_OPT_AUTOMOUNTD_NOBROWSE   3
        { "nobrowse",
            "nobrowse", PROTO_OPT_AUTOMOUNTD_NOBROWSE, SCF_TYPE_BOOLEAN,
            AUTOMOUNT_NOBROWSE_DEFAULT, 0, 1, true_false_validator},
#define PROTO_OPT_AUTOMOUNTD_TRACE      4
        { "trace",
            "trace", PROTO_OPT_AUTOMOUNTD_TRACE,
            SCF_TYPE_INTEGER, AUTOMOUNT_TRACE_DEFAULT,
            0, 20, range_check_validator},
#define PROTO_OPT_AUTOMOUNTD_ENV        5
        { "environment",
            "environment", PROTO_OPT_AUTOMOUNTD_ENV, SCF_TYPE_ASTRING,
            0, 0, 1024, strlen_validator},
        {NULL, NULL, 0, 0, 0, 0, 0, NULL}
};

#define AUTOFS_PROP_MAX (sizeof (proto_options) / sizeof (proto_options[0]))

static void
add_defaults()
{
        int i;
        char number[MAXDIGITS];

        for (i = 0; proto_options[i].tag != NULL; i++) {
                sa_property_t prop;
                prop = sa_get_protocol_property(protoset,
                    proto_options[i].name);
                if (prop == NULL) {
                        /* add the default value */
                        switch (proto_options[i].type) {
                        case SCF_TYPE_INTEGER:
                                (void) snprintf(number, sizeof (number), "%d",
                                    proto_options[i].defvalue.intval);
                                prop = sa_create_property(proto_options[i].name,
                                    number);
                                break;

                        case SCF_TYPE_BOOLEAN:
                                prop = sa_create_property(proto_options[i].name,
                                    proto_options[i].defvalue.intval ?
                                    "true" : "false");
                                break;

                        default:
                                /* treat as strings of zero length */
                                prop = sa_create_property(proto_options[i].name,
                                    "");
                                break;
                        }
                        if (prop != NULL)
                                (void) sa_add_protocol_property(protoset, prop);
                }
        }
}

static int
autofs_init()
{
        int ret = SA_OK;

        if (sa_plugin_ops.sa_init != autofs_init) {
                (void) printf(dgettext(TEXT_DOMAIN,
                    "AUTOFS plugin not installed properly\n"));
                return (SA_CONFIG_ERR);
        }

        ret = initautofsprotofromsmf();
        if (ret != SA_OK) {
                (void) printf(dgettext(TEXT_DOMAIN,
                    "AUTOFS plugin problem with SMF properties: %s\n"),
                    sa_errorstr(ret));
                ret = SA_OK;
        }
        add_defaults();
        return (ret);
}

static void
free_protoprops()
{
        if (protoset != NULL) {
                xmlFreeNode(protoset);
                protoset = NULL;
        }
}

static void
autofs_fini()
{
        free_protoprops();
}

static int
findprotoopt(char *propname)
{
        int i;

        for (i = 0; proto_options[i].tag != NULL; i++)
                if (strcmp(proto_options[i].name, propname) == 0)
                        return (i);
        return (-1);
}

static int
autofs_validate_property(sa_handle_t handle, sa_property_t property,
    sa_optionset_t parent)
{
        int ret = SA_OK;
        char *propname;
        int optionindex;
        char *value;

#ifdef lint
        handle = handle;
        parent = parent;
#endif
        propname = sa_get_property(property, "type");
        if (propname == NULL)
                return (SA_NO_SUCH_PROP);

        if ((optionindex = findprotoopt(propname)) < 0)
                ret = SA_NO_SUCH_PROP;

        if (ret != SA_OK) {
                if (propname != NULL)
                        sa_free_attr_string(propname);
                return (ret);
        }

        value = sa_get_property_attr(property, "value");
        if (value != NULL) {
                /*
                 * If any property is added to AUTOFS, which is a different
                 * type than the below list, a case needs to be added for that
                 * to check the values. For now AUTOFS type are just integers,
                 * string and boolean properties. Just taking care of them.
                 */
                switch (proto_options[optionindex].type) {
                case SCF_TYPE_INTEGER:
                case SCF_TYPE_BOOLEAN:
                case SCF_TYPE_ASTRING:
                        ret = proto_options[optionindex].check(optionindex,
                            value);
                        break;
                default:
                        break;
                }
        }

        /* Free the value */
        if (value != NULL)
                sa_free_attr_string(value);
        if (propname != NULL)
                sa_free_attr_string(propname);
        return (ret);
}

/*
 * service_in_state(service, chkstate)
 *
 * Want to know if the specified service is in the desired state
 * (chkstate) or not. Return true (1) if it is and false (0) if it
 * isn't.
 */
static int
service_in_state(char *service, const char *chkstate)
{
        char *state;
        int ret = B_FALSE;

        state = smf_get_state(service);
        if (state != NULL) {
                /* got the state so get the equality for the return value */
                ret = strcmp(state, chkstate) == 0 ? B_TRUE : B_FALSE;
                free(state);
        }
        return (ret);
}

static void
restart_service(char *service)
{
        int ret = -1;

        /*
         * Only attempt to restart the service if it is
         * currently running. In the future, it may be
         * desirable to use smf_refresh_instance if the AUTOFS
         * services ever implement the refresh method.
         */
        if (service_in_state(service, SCF_STATE_STRING_ONLINE)) {
                ret = smf_restart_instance(service);
                /*
                 * There are only a few SMF errors at this point, but
                 * it is also possible that a bad value may have put
                 * the service into maintenance if there wasn't an
                 * SMF level error.
                 */
                if (ret != 0) {
                        (void) fprintf(stderr,
                            dgettext(TEXT_DOMAIN,
                            "%s failed to restart: %s\n"),
                            scf_strerror(scf_error()));
                } else {
                        /*
                         * Check whether it has gone to "maintenance"
                         * mode or not. Maintenance implies something
                         * went wrong.
                         */
                        if (service_in_state(service,
                            SCF_STATE_STRING_MAINT)) {
                                (void) fprintf(stderr,
                                    dgettext(TEXT_DOMAIN,
                                    "%s failed to restart\n"),
                                    service);
                        }
                }
        }
}

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);
}

/*
 * fixcaselower(str)
 *
 * convert a string to lower case (inplace).
 */

static void
fixcaselower(char *str)
{
        while (*str) {
                *str = tolower(*str);
                str++;
        }
}

/*
 * skipwhitespace(str)
 *
 * Skip leading white space. It is assumed that it is called with a
 * valid pointer.
 */
static char *
skipwhitespace(char *str)
{
        while (*str && isspace(*str))
                str++;

        return (str);
}

/*
 * extractprop()
 *
 * Extract the property and value out of the line and create the
 * property in the optionset.
 */
static int
extractprop(char *name, char *value)
{
        sa_property_t prop;
        int index;
        int ret = SA_OK;
        /*
         * Remove any leading
         * white space.
         */
        name = skipwhitespace(name);

        index = findprotoopt(name);
        if (index >= 0) {
                fixcaselower(name);
                prop = sa_create_property(proto_options[index].name, value);
                if (prop != NULL)
                        ret = sa_add_protocol_property(protoset, prop);
                else
                        ret = SA_NO_MEMORY;
        }
        return (ret);
}

static int
initautofsprotofromsmf(void)
{
        char name[PATH_MAX];
        char value[PATH_MAX];
        int ret = SA_OK, bufsz = 0, i;
        char *instance = NULL;
        scf_type_t sctype;

        protoset = sa_create_protocol_properties("autofs");
        if (protoset != NULL) {
                for (i = 0; proto_options[i].tag != NULL; i++) {
                        bzero(value, PATH_MAX);
                        (void) strncpy(name, proto_options[i].name, PATH_MAX);
                        sctype = proto_options[i].type;
                        bufsz = PATH_MAX;
                        ret = autofs_smf_get_prop(name, value,
                            instance, sctype, AUTOFS_FMRI, &bufsz);
                        if (ret == SA_OK) {
                                ret = extractprop(name, value);
                        }
                }
        } else {
                ret = SA_NO_MEMORY;
        }
        return (ret);
}

static int
range_check_validator(int index, char *value)
{
        int ret = SA_OK;
        if (!is_a_number(value)) {
                ret = SA_BAD_VALUE;
        } else {
                int val;
                errno = 0;
                val = strtoul(value, NULL, 0);
                if (errno != 0)
                        return (SA_BAD_VALUE);

                if (val < proto_options[index].minval ||
                    val > proto_options[index].maxval)
                        ret = SA_BAD_VALUE;
        }
        return (ret);
}

static int
true_false_validator(int index, char *value)
{

#ifdef lint
        index = index;
#endif
        if ((strcasecmp(value, "true") == 0) ||
            (strcasecmp(value, "on") == 0) ||
            (strcasecmp(value, "yes") == 0) ||
            (strcmp(value, "1") == 0) ||
            (strcasecmp(value, "false") == 0) ||
            (strcasecmp(value, "off") == 0) ||
            (strcasecmp(value, "no") == 0) ||
            (strcmp(value, "0") == 0)) {
                return (SA_OK);
        }
        return (SA_BAD_VALUE);
}

static int
strlen_validator(int index, char *value)
{
        int ret = SA_OK;
        if (value == NULL) {
                if (proto_options[index].minval == 0) {
                        return (ret);
                } else {
                        return (SA_BAD_VALUE);
                }
        }
        if (strlen(value) > proto_options[index].maxval ||
            strlen(value) < proto_options[index].minval)
                ret = SA_BAD_VALUE;
        return (ret);
}

static int
autofs_validate_proto_prop(int index, char *name, char *value)
{
#ifdef lint
        name = name;
#endif
        return (proto_options[index].check(index, value));
}

static int
autofs_set_proto_prop(sa_property_t prop)
{
        int ret = SA_OK;
        char *name;
        char *value, *instance = NULL;
        scf_type_t sctype;

        name = sa_get_property_attr(prop, "type");
        value = sa_get_property_attr(prop, "value");
        if (name != NULL && value != NULL) {
                int index = findprotoopt(name);
                if (index >= 0) {
                        ret = autofs_validate_proto_prop(index, name, value);
                        if (ret == SA_OK) {
                                sctype = proto_options[index].type;
                                if (sctype == SCF_TYPE_BOOLEAN) {
                                        if (value != NULL)
                                                sa_free_attr_string(value);
                                        if (string_to_boolean(value) == 0)
                                                value = strdup("0");
                                        else
                                                value = strdup("1");
                                }
                                ret = autofs_smf_set_prop(name, value,
                                    instance, sctype, AUTOFS_FMRI);
                                /*
                                 * Make an instance based FMRI.
                                 * For now its DEFAULT_AUTOFS_FMRI.
                                 */
                                if (ret == SA_OK)
                                        restart_service(AUTOFS_DEFAULT_FMRI);
                        }
                } else {
                        ret = SA_NO_SUCH_PROP;
                }
        } else {
                ret = SA_CONFIG_ERR;
        }

        if (name != NULL)
                sa_free_attr_string(name);
        if (value != NULL)
                sa_free_attr_string(value);
        return (ret);
}


static sa_protocol_properties_t
autofs_get_proto_set(void)
{
        return (protoset);
}

static uint64_t
autofs_features(void)
{
        return (0);
}

static char *
autofs_get_status(void)
{
        return (smf_get_state(AUTOFS_DEFAULT_FMRI));
}