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

#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <strings.h>
#include <libintl.h>
#include <libscf.h>
#include <libnvpair.h>

#include <libstmf.h>
#include <libsrpt.h>

#include "srpt_common.h"

#define SRPT_PROV_NAME  "srpt"

/*
 * Function:  srpt_GetConfig()
 *
 * Parameters:
 *    cfg       Current SRPT configuration in nvlist form
 *    token     Configuration generation number.  Use this token
 *              if updating the configuration with srpt_SetConfig.
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 */
int
srpt_GetConfig(nvlist_t **cfg, uint64_t *token)
{
        int             ret = 0;
        nvlist_t        *cfg_nv = NULL;
        uint64_t        stmf_token = 0;
        nvlist_t        *hcanv = NULL;

        if (!cfg) {
                return (EINVAL);
        }

        *cfg = NULL;

        ret = stmfGetProviderDataProt(SRPT_PROV_NAME, &cfg_nv,
            STMF_PORT_PROVIDER_TYPE, &stmf_token);

        if (ret == STMF_STATUS_SUCCESS) {
                ret = 0;
        } else if (ret == STMF_ERROR_NOT_FOUND) {
                /* Not initialized yet */
                ret = nvlist_alloc(&cfg_nv, NV_UNIQUE_NAME, 0);
                if (ret != 0) {
                        return (ret);
                }
                /* create the HCA list */
                ret = nvlist_alloc(&hcanv, NV_UNIQUE_NAME, 0);
                if (ret == 0) {
                        ret = nvlist_add_nvlist(cfg_nv, SRPT_PROP_HCALIST,
                            hcanv);
                        if (ret != 0) {
                                nvlist_free(hcanv);
                        }
                }
                if (ret != 0) {
                        nvlist_free(cfg_nv);
                        cfg_nv = NULL;
                }
        } else if (ret == STMF_ERROR_NOMEM) {
                ret = ENOMEM;
        } else {
                ret = EINVAL;
        }

        *cfg = cfg_nv;
        *token = stmf_token;

        return (ret);
}

/*
 * Function:  srpt_SetConfig()
 *
 * Parameters:
 *    cfg       SRPT configuration in nvlist form
 *    token     Configuration generation number from srpt_GetConfig.
 *              Use this token to ensure the configuration hasn't been
 *              updated by another user since the time it was fetched.
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 *    ECANCELED Configuration updated by another user
 */
int
srpt_SetConfig(nvlist_t *cfg, uint64_t token)
{
        int             ret = 0;

        ret = stmfSetProviderDataProt(SRPT_PROV_NAME, cfg,
            STMF_PORT_PROVIDER_TYPE, &token);

        if (ret == STMF_STATUS_SUCCESS) {
                ret = 0;
        } else if (ret == STMF_ERROR_NOMEM) {
                ret = ENOMEM;
        } else if (ret == STMF_ERROR_PROV_DATA_STALE) {
                ret = ECANCELED;  /* could be a better errno */
        } else {
                ret = EINVAL;
        }

        return (ret);
}

/*
 * Function:  srpt_GetDefaultState()
 *
 * Parameters:
 *    enabled   If B_TRUE, indicates that targets will be created for all
 *              discovered HCAs that have not been specifically disabled.
 *              If B_FALSE, targets will not be created unless the HCA has
 *              been specifically enabled.  See also srpt_SetDefaultState().
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 */
int
srpt_GetDefaultState(boolean_t *enabled)
{
        int             ret;
        nvlist_t        *cfgnv;
        uint64_t        token;
        boolean_t       val = B_TRUE;

        if (enabled == NULL) {
                return (EINVAL);
        }

        ret = srpt_GetConfig(&cfgnv, &token);
        if (ret != 0) {
                return (ret);
        }

        if (cfgnv != NULL) {
                ret = nvlist_lookup_boolean_value(cfgnv,
                    SRPT_PROP_DEFAULT_ENABLED, &val);

                if (ret == ENOENT) {
                        ret = 0;
                }
        }

        *enabled = val;
        return (ret);
}

/*
 * Function:  srpt_SetDefaultState()
 *
 * Parameters:
 *    enabled   If B_TRUE, indicates that targets will be created for all
 *              discovered HCAs that have not been specifically disabled.
 *              If B_FALSE, targets will not be created unless the HCA has
 *              been specifically enabled.  See also srpt_SetDefaultState().
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 */
int
srpt_SetDefaultState(boolean_t enabled)
{
        int             ret;
        nvlist_t        *cfgnv;
        uint64_t        token;

        ret = srpt_GetConfig(&cfgnv, &token);
        if (ret != 0) {
                return (ret);
        }

        if (cfgnv == NULL) {
                ret = nvlist_alloc(&cfgnv, NV_UNIQUE_NAME, 0);
                if (ret != 0) {
                        return (ret);
                }
        }

        ret = nvlist_add_boolean_value(cfgnv, SRPT_PROP_DEFAULT_ENABLED,
            enabled);

        if (ret == 0) {
                ret = srpt_SetConfig(cfgnv, token);
        }

        nvlist_free(cfgnv);

        return (ret);
}

/*
 * Function:  srpt_SetTargetState()
 *
 * Parameters:
 *    hca_guid  HCA GUID.  See description of srpt_NormalizeGuid
 *    enabled   If B_TRUE, indicates that a target will be created for
 *              this HCA when the SRPT SMF service is enabled.  If B_FALSE,
 *              a target will not be created
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 */
int
srpt_SetTargetState(char *hca_guid, boolean_t enabled)
{
        int             ret;
        nvlist_t        *cfgnv;
        uint64_t        token;
        nvlist_t        *hcalist;
        nvlist_t        *hcanv;
        char            guid[32];
        uint64_t        hcaguid;

        if (hca_guid == NULL) {
                return (EINVAL);
        }

        ret = srpt_NormalizeGuid(hca_guid, guid, sizeof (guid), &hcaguid);
        if (ret != 0) {
                return (ret);
        }

        ret = srpt_GetConfig(&cfgnv, &token);
        if (ret != 0) {
                return (ret);
        }

        /* get the list of HCAs */
        ret = nvlist_lookup_nvlist(cfgnv, SRPT_PROP_HCALIST, &hcalist);
        if (ret != 0) {
                nvlist_free(cfgnv);
                return (ret);
        }

        ret = nvlist_lookup_nvlist(hcalist, guid, &hcanv);
        if (ret == ENOENT) {
                /* no entry yet */
                ret = nvlist_alloc(&hcanv, NV_UNIQUE_NAME, 0);
                if (ret == 0) {
                        ret = nvlist_add_uint64(hcanv, SRPT_PROP_GUID, hcaguid);
                }
        }

        if (ret == 0) {
                ret = nvlist_add_boolean_value(hcanv, SRPT_PROP_ENABLED,
                    enabled);
        }

        if (ret == 0) {
                ret = nvlist_add_nvlist(hcalist, guid, hcanv);
        }

        if (ret == 0) {
                ret = srpt_SetConfig(cfgnv, token);
        }

        nvlist_free(cfgnv);

        return (ret);
}

/*
 * Function:  srpt_GetTargetState()
 *
 * Parameters:
 *    hca_guid  HCA GUID.  See description of srpt_NormalizeGuid
 *    enabled   If B_TRUE, indicates that a target will be created for
 *              this HCA when the SRPT SMF service is enabled.  If B_FALSE,
 *              a target will not be created
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 */
int
srpt_GetTargetState(char *hca_guid, boolean_t *enabled)
{
        int             ret;
        nvlist_t        *cfgnv;
        uint64_t        token;
        nvlist_t        *hcalist;
        nvlist_t        *hcanv;
        boolean_t       defaultState = B_TRUE;
        char            guid[32];

        if (hca_guid == NULL) {
                return (EINVAL);
        }

        ret = srpt_NormalizeGuid(hca_guid, guid, sizeof (guid), NULL);
        if (ret != 0) {
                return (ret);
        }

        ret = srpt_GetConfig(&cfgnv, &token);
        if (ret != 0) {
                return (ret);
        }

        /* get the list of HCAs */
        ret = nvlist_lookup_nvlist(cfgnv, SRPT_PROP_HCALIST, &hcalist);
        if (ret != 0) {
                nvlist_free(cfgnv);
                return (ret);
        }

        /*
         * Find the default, for the likely case that this HCA isn't
         * explicitly set.
         */
        (void) nvlist_lookup_boolean_value(cfgnv, SRPT_PROP_DEFAULT_ENABLED,
            &defaultState);

        ret = nvlist_lookup_nvlist(hcalist, guid, &hcanv);
        if (ret == 0) {
                ret = nvlist_lookup_boolean_value(hcanv, SRPT_PROP_ENABLED,
                    enabled);
        }

        if (ret == ENOENT) {
                /* not explicitly set, use the default */
                *enabled = defaultState;
                ret = 0;
        }

        nvlist_free(cfgnv);

        return (ret);

}

/*
 * Function:  srpt_ResetTarget()
 *
 * Clears the HCA-specific configuration.  Target creation will revert to
 * the default.
 *
 * Parameters:
 *    hca_guid  HCA GUID.  See description of srpt_NormalizeGuid
 *
 * Return Values:
 *    0         Success
 *    ENOMEM    Could not allocate resources
 *    EINVAL    Invalid parameter
 */
int
srpt_ResetTarget(char *hca_guid)
{
        int             ret;
        nvlist_t        *cfgnv;
        nvlist_t        *hcalist;
        uint64_t        token;
        char            guid[32];

        if (hca_guid == NULL) {
                return (EINVAL);
        }

        ret = srpt_NormalizeGuid(hca_guid, guid, sizeof (guid), NULL);
        if (ret != 0) {
                return (ret);
        }

        ret = srpt_GetConfig(&cfgnv, &token);
        if (ret != 0) {
                return (ret);
        }

        /* get the list of HCAs */
        ret = nvlist_lookup_nvlist(cfgnv, SRPT_PROP_HCALIST, &hcalist);
        if (ret != 0) {
                nvlist_free(cfgnv);
                return (ret);
        }

        /* don't set config if we don't actually change anything */
        if (nvlist_exists(hcalist, guid)) {
                (void) nvlist_remove_all(hcalist, guid);

                if (ret == 0) {
                        ret = srpt_SetConfig(cfgnv, token);
                }
        }

        nvlist_free(cfgnv);

        return (ret);
}

/*
 * srpt_NormalizeGuid()
 *
 * Parameters:
 *    in        HCA GUID.  Must be in one of the following forms:
 *                  3BA000100CD18       - base hex form
 *                  0003BA000100CD18    - base hex form with leading zeroes
 *                  hca:3BA000100CD18   - form from cfgadm and/or /dev/cfg
 *                  eui.0003BA000100CD18 - EUI form
 *
 *    buf       Buffer to hold normalized guid string.  Must be at least
 *              17 chars long.
 *    buflen    Length of provided buffer
 *    int_guid  Optional.  If not NULL, the integer form of the GUID will also
 *              be returned.
 * Return Values:
 *    0         Success
 *    EINVAL    Invalid HCA GUID or invalid parameter.
 */
int
srpt_NormalizeGuid(char *in, char *buf, size_t buflen, uint64_t *int_guid)
{
        uint64_t        guid;
        char            *bufp = in;
        char            *end = NULL;

        if ((in == NULL) || (buf == NULL)) {
                return (EINVAL);
        }

        if (strncasecmp(bufp, "eui.", 4) == 0) {
                /* EUI form */
                bufp += 4;
        } else if (strncasecmp(bufp, "hca:", 4) == 0) {
                /* cfgadm and /dev/hca form */
                bufp += 4;
        }

        /*
         * strtoull() does not return EINVAL as documented.  Lucky
         * for us, neither 0 nor ULLONG_MAX will be valid.  Trap on
         * those and fail.
         */
        guid = strtoull(bufp, &end, 16);
        if ((guid == 0) || (guid == ULLONG_MAX) ||
            ((end != NULL) && (strlen(end) > 0))) {
                return (EINVAL);
        }

#if 0
        (void) snprintf(buf, buflen, "%llX", guid);
#endif
        SRPT_FORMAT_HCAKEY(buf, buflen, guid);

        if (int_guid) {
                *int_guid = guid;
        }

        return (0);
}