/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *      - Redistributions of source code must retain the above copyright
 *        notice, this list of conditions and the following disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above copyright
 *        notice, this list of conditions and the following disclaimer in
 *        the documentation and/or other materials provided with the
 *        distribution.
 *
 *      - Neither the name of The Storage Networking Industry Association (SNIA)
 *        nor the names of its contributors may be used to endorse or promote
 *        products derived from this software without specific prior written
 *        permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * NDMP configuration management
 */
#include <stdio.h>
#include <stdlib.h>
#include <synch.h>
#include <libintl.h>
#include <strings.h>
#include <libndmp.h>

/* NDMP properties configuration */
#define NDMP_GROUP_FMRI_PREFIX  "system/ndmpd"
#define NDMP_INST               "svc:/system/ndmpd:default"
#define NDMP_PROP_LEN           600
static char *ndmp_pg[] = {
        "ndmpd",
        "read"
};
#define NPG     (sizeof (ndmp_pg) / sizeof (ndmp_pg[0]))

/* Handle Init states */
#define NDMP_SCH_STATE_UNINIT           0
#define NDMP_SCH_STATE_INITIALIZING     1
#define NDMP_SCH_STATE_INIT             2

/* NDMP scf handle structure */
typedef struct ndmp_scfhandle {
        scf_handle_t *scf_handle;
        int scf_state;
        scf_service_t *scf_service;
        scf_scope_t *scf_scope;
        scf_transaction_t *scf_trans;
        scf_propertygroup_t *scf_pg;
} ndmp_scfhandle_t;

static int ndmp_config_saveenv(ndmp_scfhandle_t *, boolean_t);
static ndmp_scfhandle_t *ndmp_smf_scf_init(const char *);
static void ndmp_smf_scf_fini(ndmp_scfhandle_t *);
static int ndmp_smf_start_transaction(ndmp_scfhandle_t *);
static int ndmp_smf_end_transaction(ndmp_scfhandle_t *, boolean_t);
static int ndmp_smf_set_property(ndmp_scfhandle_t *, const char *,
                const char *);
static int ndmp_smf_get_property(ndmp_scfhandle_t *, const char *, char *,
                size_t);
static int ndmp_smf_create_service_pgroup(ndmp_scfhandle_t *, const char *);
static int ndmp_smf_delete_property(ndmp_scfhandle_t *, const char *);
static int ndmp_smf_get_pg_name(ndmp_scfhandle_t *, const char *, char **);

/*
 * This routine send a refresh signal to ndmpd service which cause ndmpd
 * property table to be refeshed with current ndmpd properties value from SMF.
 */
int
ndmp_service_refresh(void)
{
        int rc = smf_refresh_instance(NDMP_INST);

        if (rc != 0)
                ndmp_errno = ENDMP_SMF_INTERNAL;
        return (rc);
}

/*
 * Returns value of the specified variable/property. The return value is a
 * string pointer to the locally allocated memory if the config param is
 * defined otherwise it would be NULL.
 */
int
ndmp_get_prop(const char *prop, char **value)
{
        ndmp_scfhandle_t *handle;
        char *lval;
        char *pgname;

        *value = NULL;
        if ((handle = ndmp_smf_scf_init(NDMP_GROUP_FMRI_PREFIX)) == NULL) {
                return (-1);
        }
        if (ndmp_smf_get_pg_name(handle, prop, &pgname)) {
                ndmp_smf_scf_fini(handle);
                ndmp_errno = ENDMP_SMF_PROP_GRP;
                return (-1);
        }
        if (ndmp_smf_create_service_pgroup(handle, pgname)) {
                ndmp_smf_scf_fini(handle);
                return (-1);
        }
        if ((lval = malloc(NDMP_PROP_LEN)) == NULL) {
                ndmp_smf_scf_fini(handle);
                ndmp_errno = ENDMP_MEM_ALLOC;
                return (-1);
        }
        if (ndmp_smf_get_property(handle, prop, lval, NDMP_PROP_LEN) != 0) {
                ndmp_smf_scf_fini(handle);
                free(lval);
                ndmp_errno = ENDMP_SMF_PROP;
                return (-1);
        }
        *value = lval;
        ndmp_smf_scf_fini(handle);
        return (0);
}

int
ndmp_set_prop(const char *env, const char *env_val)
{
        ndmp_scfhandle_t *handle;
        char *pgname;
        int rc;

        if ((handle = ndmp_smf_scf_init(NDMP_GROUP_FMRI_PREFIX)) == NULL)
                return (-1);

        if (ndmp_smf_get_pg_name(handle, env, &pgname)) {
                ndmp_smf_scf_fini(handle);
                ndmp_errno = ENDMP_SMF_PROP_GRP;
                return (-1);
        }

        if (ndmp_smf_create_service_pgroup(handle, pgname)) {
                ndmp_smf_scf_fini(handle);
                return (-1);
        }

        if (ndmp_smf_start_transaction(handle)) {
                ndmp_smf_scf_fini(handle);
                return (-1);
        }

        if (env_val)
                rc = ndmp_smf_set_property(handle, env, env_val);
        else
                rc = ndmp_smf_delete_property(handle, env);

        if (ndmp_config_saveenv(handle, (rc == 0)) == 0)
                return (rc);
        else
                return (-1);
}

static int
ndmp_smf_get_pg_name(ndmp_scfhandle_t *h, const char *pname, char **pgname)
{
        scf_value_t *value;
        scf_property_t *prop;
        int i;

        for (i = 0; i < NPG; i++) {
                if (scf_service_get_pg(h->scf_service, ndmp_pg[i],
                    h->scf_pg) != 0)
                        return (-1);

                if ((value = scf_value_create(h->scf_handle)) == NULL)
                        return (-1);

                if ((prop = scf_property_create(h->scf_handle)) == NULL) {
                        scf_value_destroy(value);
                        return (-1);
                }
                /*
                 * This will fail if property does not exist in the property
                 * group. Check the next property group in case of failure.
                 */
                if ((scf_pg_get_property(h->scf_pg, pname, prop)) != 0) {
                        scf_value_destroy(value);
                        scf_property_destroy(prop);
                        continue;
                }

                *pgname = ndmp_pg[i];
                scf_value_destroy(value);
                scf_property_destroy(prop);
                return (0);
        }
        return (-1);
}

/*
 * Basically commit the transaction.
 */
static int
ndmp_config_saveenv(ndmp_scfhandle_t *handle, boolean_t commit)
{
        int ret = 0;

        ret = ndmp_smf_end_transaction(handle, commit);

        ndmp_smf_scf_fini(handle);
        return (ret);
}

/*
 * Must be called when done. Called with the handle allocated in
 * ndmp_smf_scf_init(), it cleans up the state and frees any SCF resources
 * still in use.
 */
static void
ndmp_smf_scf_fini(ndmp_scfhandle_t *handle)
{
        if (handle == NULL)
                return;

        scf_scope_destroy(handle->scf_scope);
        scf_service_destroy(handle->scf_service);
        scf_pg_destroy(handle->scf_pg);
        handle->scf_state = NDMP_SCH_STATE_UNINIT;
        (void) scf_handle_unbind(handle->scf_handle);
        scf_handle_destroy(handle->scf_handle);
        free(handle);
}

/*
 * Must be called before using any of the SCF functions. Returns
 * ndmp_scfhandle_t pointer if success.
 */
static ndmp_scfhandle_t *
ndmp_smf_scf_init(const char *svc_name)
{
        ndmp_scfhandle_t *handle;

        handle = (ndmp_scfhandle_t *)calloc(1, sizeof (ndmp_scfhandle_t));
        if (handle != NULL) {
                handle->scf_state = NDMP_SCH_STATE_INITIALIZING;
                if (((handle->scf_handle =
                    scf_handle_create(SCF_VERSION)) != NULL) &&
                    (scf_handle_bind(handle->scf_handle) == 0)) {
                        if ((handle->scf_scope =
                            scf_scope_create(handle->scf_handle)) == NULL)
                                goto err;

                        if (scf_handle_get_local_scope(handle->scf_handle,
                            handle->scf_scope) != 0)
                                goto err;

                        if ((handle->scf_service =
                            scf_service_create(handle->scf_handle)) == NULL)
                                goto err;

                        if (scf_scope_get_service(handle->scf_scope, svc_name,
                            handle->scf_service) != SCF_SUCCESS)
                                goto err;

                        if ((handle->scf_pg =
                            scf_pg_create(handle->scf_handle)) == NULL)
                                goto err;

                        handle->scf_state = NDMP_SCH_STATE_INIT;
                } else {
                        goto err;
                }
        } else {
                ndmp_errno = ENDMP_MEM_ALLOC;
                handle = NULL;
        }
        return (handle);

        /* Error handling/unwinding */
err:
        (void) ndmp_smf_scf_fini(handle);
        ndmp_errno = ENDMP_SMF_INTERNAL;
        return (NULL);
}

/*
 * Create a new property group at service level.
 */
static int
ndmp_smf_create_service_pgroup(ndmp_scfhandle_t *handle, const char *pgroup)
{
        int err;

        /*
         * Only create a handle if it doesn't exist. It is ok to exist since
         * the pg handle will be set as a side effect.
         */
        if (handle->scf_pg == NULL) {
                if ((handle->scf_pg =
                    scf_pg_create(handle->scf_handle)) == NULL) {
                        ndmp_errno = ENDMP_SMF_INTERNAL;
                        return (-1);
                }
        }

        /*
         * If the pgroup exists, we are done. If it doesn't, then we need to
         * actually add one to the service instance.
         */
        if (scf_service_get_pg(handle->scf_service,
            pgroup, handle->scf_pg) != 0) {
                /* Doesn't exist so create one */
                if (scf_service_add_pg(handle->scf_service, pgroup,
                    SCF_GROUP_FRAMEWORK, 0, handle->scf_pg) != 0) {
                        err = scf_error();
                        switch (err) {
                        case SCF_ERROR_PERMISSION_DENIED:
                                ndmp_errno = ENDMP_SMF_PERM;
                                return (-1);
                        default:
                                ndmp_errno = ENDMP_SMF_INTERNAL;
                                return (-1);
                        }
                }
        }
        return (0);
}

/*
 * Start transaction on current pg in handle. The pg could be service or
 * instance level. Must be called after pg handle is obtained from create or
 * get.
 */
static int
ndmp_smf_start_transaction(ndmp_scfhandle_t *handle)
{
        /*
         * Lookup the property group and create it if it doesn't already
         * exist.
         */
        if (handle->scf_state == NDMP_SCH_STATE_INIT) {
                if ((handle->scf_trans =
                    scf_transaction_create(handle->scf_handle)) != NULL) {
                        if (scf_transaction_start(handle->scf_trans,
                            handle->scf_pg) != 0) {
                                scf_transaction_destroy(handle->scf_trans);
                                handle->scf_trans = NULL;
                                ndmp_errno = ENDMP_SMF_INTERNAL;
                                return (-1);
                        }
                } else {
                        ndmp_errno = ENDMP_SMF_INTERNAL;
                        return (-1);
                }
        }
        if (scf_error() == SCF_ERROR_PERMISSION_DENIED) {
                ndmp_errno = ENDMP_SMF_PERM;
                return (-1);
        }

        return (0);
}

/*
 * Commit the changes that were added to the transaction in the handle. Do all
 * necessary cleanup.
 */
static int
ndmp_smf_end_transaction(ndmp_scfhandle_t *handle, boolean_t commit)
{
        int rc = 0;

        if (commit) {
                if (scf_transaction_commit(handle->scf_trans) < 0) {
                        ndmp_errno = ENDMP_SMF_INTERNAL;
                        rc = -1;
                }
        }

        scf_transaction_destroy_children(handle->scf_trans);
        scf_transaction_destroy(handle->scf_trans);
        handle->scf_trans = NULL;

        return (rc);
}

/*
 * Deletes property in current pg
 */
static int
ndmp_smf_delete_property(ndmp_scfhandle_t *handle, const char *propname)
{
        scf_transaction_entry_t *entry = NULL;

        /*
         * Properties must be set in transactions and don't take effect until
         * the transaction has been ended/committed.
         */
        if ((entry = scf_entry_create(handle->scf_handle)) != NULL) {
                if (scf_transaction_property_delete(handle->scf_trans, entry,
                    propname) != 0) {
                        scf_entry_destroy(entry);
                        ndmp_errno = ENDMP_SMF_INTERNAL;
                        return (-1);
                }
        } else {
                ndmp_errno = ENDMP_SMF_INTERNAL;
                return (-1);
        }
        if ((scf_error()) == SCF_ERROR_PERMISSION_DENIED) {
                ndmp_errno = ENDMP_SMF_PERM;
                scf_entry_destroy(entry);
                return (-1);
        }

        return (0);
}

/*
 * Sets property in current pg
 */
static int
ndmp_smf_set_property(ndmp_scfhandle_t *handle, const char *propname,
    const char *valstr)
{
        int ret = 0;
        scf_value_t *value = NULL;
        scf_transaction_entry_t *entry = NULL;
        scf_property_t *prop = NULL;
        scf_type_t type;
        int64_t valint;
        uint8_t valbool;

        /*
         * Properties must be set in transactions and don't take effect until
         * the transaction has been ended/committed.
         */
        if (((value = scf_value_create(handle->scf_handle)) == NULL) ||
            ((entry = scf_entry_create(handle->scf_handle)) == NULL) ||
            ((prop = scf_property_create(handle->scf_handle)) == NULL) ||
            (scf_pg_get_property(handle->scf_pg, propname, prop) != 0) ||
            (scf_property_get_value(prop, value) != 0)) {
                ret = -1;
                goto out;
        }

        type = scf_value_type(value);
        if ((scf_transaction_property_change(handle->scf_trans, entry, propname,
            type) != 0) &&
            (scf_transaction_property_new(handle->scf_trans, entry, propname,
            type) != 0)) {
                ret = -1;
                goto out;
        }

        switch (type) {
        case SCF_TYPE_ASTRING:
                if ((scf_value_set_astring(value, valstr)) != SCF_SUCCESS)
                        ret = -1;
                break;
        case SCF_TYPE_INTEGER:
                valint = strtoll(valstr, 0, 0);
                scf_value_set_integer(value, valint);
                break;
        case SCF_TYPE_BOOLEAN:
                if (strncmp(valstr, "yes", 3))
                        valbool = 0;
                else
                        valbool = 1;
                scf_value_set_boolean(value, valbool);
                break;
        default:
                ret = -1;
        }
        if (scf_entry_add_value(entry, value) == 0) {
                /* The value is in the transaction */
                value = NULL;
        } else {
                ret = -1;
        }
        /* The entry is in the transaction */
        entry = NULL;

out:
        if (ret == -1) {
                if ((scf_error() == SCF_ERROR_PERMISSION_DENIED))
                        ndmp_errno = ENDMP_SMF_PERM;
                else
                        ndmp_errno = ENDMP_SMF_INTERNAL;
        }
        scf_property_destroy(prop);
        scf_value_destroy(value);
        scf_entry_destroy(entry);
        return (ret);
}

/*
 * Gets a property value.upto sz size. Caller is responsible to have enough
 * memory allocated.
 */
static int
ndmp_smf_get_property(ndmp_scfhandle_t *handle, const char *propname,
    char *valstr, size_t sz)
{
        int ret = 0;
        scf_value_t *value = NULL;
        scf_property_t *prop = NULL;
        scf_type_t type;
        int64_t valint;
        uint8_t valbool;
        char valstrbuf[NDMP_PROP_LEN];

        if (((value = scf_value_create(handle->scf_handle)) != NULL) &&
            ((prop = scf_property_create(handle->scf_handle)) != NULL) &&
            (scf_pg_get_property(handle->scf_pg, propname, prop) == 0)) {
                if (scf_property_get_value(prop, value) == 0) {
                        type = scf_value_type(value);
                        switch (type) {
                        case SCF_TYPE_ASTRING:
                                if (scf_value_get_astring(value, valstr,
                                    sz) < 0) {
                                        ret = -1;
                                }
                                break;
                        case SCF_TYPE_INTEGER:
                                if (scf_value_get_integer(value,
                                    &valint) != 0) {
                                        ret = -1;
                                        break;
                                }
                                valstrbuf[NDMP_PROP_LEN - 1] = '\0';
                                (void) strncpy(valstr, lltostr(valint,
                                    &valstrbuf[NDMP_PROP_LEN - 1]),
                                    NDMP_PROP_LEN);
                                break;
                        case SCF_TYPE_BOOLEAN:
                                if (scf_value_get_boolean(value,
                                    &valbool) != 0) {
                                        ret = -1;
                                        break;
                                }
                                if (valbool == 1)
                                        (void) strncpy(valstr, "yes", 4);
                                else
                                        (void) strncpy(valstr, "no", 3);
                                break;
                        default:
                                ret = -1;
                        }
                } else {
                        ret = -1;
                }
        } else {
                ret = -1;
        }
        scf_value_destroy(value);
        scf_property_destroy(prop);
        return (ret);
}