/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (c) 2012 Joyent, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>

#include <libipd.h>
#include <sys/ipd.h>

__thread ipd_errno_t ipd_errno = 0;
__thread char ipd_errmsg[512];

struct ipd_stat {
        uint_t is_nzones;
        zoneid_t *is_zoneids;
        struct ipd_config *is_configs;
};

static ipd_errno_t
xlate_errno(int e)
{
        switch (e) {
        case 0:
                return (EIPD_NOERROR);
        case ENOMEM:
        case EAGAIN:
                return (EIPD_NOMEM);
        case ERANGE:
                return (EIPD_RANGE);
        case EPERM:
                return (EIPD_PERM);
        case EFAULT:
                return (EIPD_FAULT);
        case ENOTTY:
                return (EIPD_INTERNAL);
        default:
                return (EIPD_UNKNOWN);
        }
}

const char *
ipd_strerror(ipd_errno_t e)
{
        switch (e) {
        case EIPD_NOERROR:
                return ("no error");
        case EIPD_NOMEM:
                return ("out of memory");
        case EIPD_ZC_NOENT:
                return ("zone does not exist or is not using ipd");
        case EIPD_RANGE:
                return ("argument out of range");
        case EIPD_PERM:
                return ("permission denied");
        case EIPD_FAULT:
                return ("bad pointer");
        case EIPD_INTERNAL:
                return ("internal library error");
        case EIPD_UNKNOWN:
        default:
                return ("unknown error");
        }
}

static int
ipd_set_errno(ipd_errno_t e, const char *fmt, ...)
{
        va_list ap;

        ipd_errno = e;
        if (fmt != NULL) {
                va_start(ap, fmt);
                (void) vsnprintf(ipd_errmsg, sizeof (ipd_errmsg), fmt, ap);
                va_end(ap);
        } else {
                (void) strlcpy(ipd_errmsg,
                    ipd_strerror(e), sizeof (ipd_errmsg));
        }

        return (-1);
}

int
ipd_open(const char *path)
{
        int fd;

        if (path == NULL)
                path = IPD_DEV_PATH;

        fd = open(path, O_RDWR);
        if (fd < 0) {
                return (ipd_set_errno(xlate_errno(errno),
                    "unable to open %s: %s", path, strerror(errno)));
        }

        return (fd);
}

int
ipd_close(int fd)
{
        (void) close(fd);
        return (0);
}

int
ipd_status_read(int fd, ipd_stathdl_t *ispp)
{
        struct ipd_stat *isp = NULL;
        ipd_ioc_list_t ipil;
        uint_t rzones;
        uint_t i;

        bzero(&ipil, sizeof (ipil));
        if (ioctl(fd, IPDIOC_LIST, &ipil) != 0) {
                return (ipd_set_errno(xlate_errno(errno),
                    "unable to retrieve ipd zone list: %s", strerror(errno)));
        }

        for (;;) {
                if ((rzones = ipil.ipil_nzones) == 0)
                        break;

                ipil.ipil_info =
                    malloc(sizeof (ipd_ioc_info_t) * ipil.ipil_nzones);
                if (ipil.ipil_info == NULL)
                        return (ipd_set_errno(EIPD_NOMEM, NULL));

                if (ioctl(fd, IPDIOC_LIST, &ipil) != 0) {
                        free(ipil.ipil_info);
                        return (ipd_set_errno(xlate_errno(errno),
                            "unable to retrieve ipd zone list: %s",
                            strerror(errno)));
                }

                if (ipil.ipil_nzones <= rzones)
                        break;

                free(ipil.ipil_info);
        }

        if ((isp = malloc(sizeof (struct ipd_stat))) == NULL) {
                free(ipil.ipil_info);
                return (ipd_set_errno(EIPD_NOMEM, NULL));
        }

        isp->is_nzones = ipil.ipil_nzones;

        if (isp->is_nzones == 0) {
                isp->is_zoneids = NULL;
                isp->is_configs = NULL;
                *ispp = isp;
                return (0);
        }

        isp->is_zoneids = malloc(sizeof (zoneid_t) * ipil.ipil_nzones);
        if (isp->is_zoneids == NULL) {
                free(ipil.ipil_info);
                free(isp);
                return (ipd_set_errno(EIPD_NOMEM, NULL));
        }
        isp->is_configs = malloc(sizeof (struct ipd_config) * ipil.ipil_nzones);
        if (isp->is_configs == NULL) {
                free(ipil.ipil_info);
                free(isp->is_zoneids);
                free(isp);
                return (ipd_set_errno(EIPD_NOMEM, NULL));
        }

        for (i = 0; i < isp->is_nzones; i++) {
                isp->is_zoneids[i] = ipil.ipil_info[i].ipii_zoneid;

                isp->is_configs[i].ic_corrupt = ipil.ipil_info[i].ipii_corrupt;
                isp->is_configs[i].ic_drop = ipil.ipil_info[i].ipii_drop;
                isp->is_configs[i].ic_delay = ipil.ipil_info[i].ipii_delay;

                isp->is_configs[i].ic_mask =
                    ((!!isp->is_configs[i].ic_corrupt) * IPDM_CORRUPT) |
                    ((!!isp->is_configs[i].ic_drop) * IPDM_DROP) |
                    ((!!isp->is_configs[i].ic_delay) * IPDM_DELAY);
        }

        *ispp = isp;
        return (0);
}

void
ipd_status_foreach_zone(const ipd_stathdl_t hdl, ipd_status_cb_f f, void *arg)
{
        const struct ipd_stat *isp = hdl;
        uint_t i;

        for (i = 0; i < isp->is_nzones; i++)
                f(isp->is_zoneids[i], &isp->is_configs[i], arg);
}

int
ipd_status_get_config(const ipd_stathdl_t hdl, zoneid_t z, ipd_config_t **icpp)
{
        const struct ipd_stat *isp = hdl;
        uint_t i;

        for (i = 0; i < isp->is_nzones; i++) {
                if (isp->is_zoneids[i] == z) {
                        *icpp = &isp->is_configs[i];
                        return (0);
                }
        }

        return (ipd_set_errno(EIPD_ZC_NOENT,
            "zone %d does not exist or has no ipd configuration", z));
}

void
ipd_status_free(ipd_stathdl_t hdl)
{
        struct ipd_stat *isp = hdl;

        if (isp != NULL) {
                free(isp->is_zoneids);
                free(isp->is_configs);
        }
        free(isp);
}

int
ipd_ctl(int fd, zoneid_t z, const ipd_config_t *icp)
{
        ipd_ioc_perturb_t ipip;

        bzero(&ipip, sizeof (ipd_ioc_perturb_t));
        ipip.ipip_zoneid = z;

        if (icp->ic_mask & IPDM_CORRUPT) {
                if (icp->ic_corrupt == 0)
                        ipip.ipip_arg |= IPD_CORRUPT;
        }
        if (icp->ic_mask & IPDM_DELAY) {
                if (icp->ic_delay == 0)
                        ipip.ipip_arg |= IPD_DELAY;
        }
        if (icp->ic_mask & IPDM_DROP) {
                if (icp->ic_drop == 0)
                        ipip.ipip_arg |= IPD_DROP;
        }

        if (ipip.ipip_arg != 0 && ioctl(fd, IPDIOC_REMOVE, &ipip) != 0) {
                return (ipd_set_errno(xlate_errno(errno),
                    "unable to remove cleared ipd settings: %s",
                    strerror(errno)));
        }

        if ((icp->ic_mask & IPDM_CORRUPT) && icp->ic_corrupt != 0) {
                ipip.ipip_zoneid = z;
                ipip.ipip_arg = icp->ic_corrupt;
                if (ioctl(fd, IPDIOC_CORRUPT, &ipip) != 0) {
                        return (ipd_set_errno(xlate_errno(errno),
                            "unable to set corruption rate to %d: %s",
                            ipip.ipip_arg, strerror(errno)));
                }
        }
        if ((icp->ic_mask & IPDM_DELAY) && icp->ic_delay != 0) {
                ipip.ipip_zoneid = z;
                ipip.ipip_arg = icp->ic_delay;
                if (ioctl(fd, IPDIOC_DELAY, &ipip) != 0) {
                        return (ipd_set_errno(xlate_errno(errno),
                            "unable to set delay time to %d: %s",
                            ipip.ipip_arg, strerror(errno)));
                }
        }
        if ((icp->ic_mask & IPDM_DROP) && icp->ic_drop != 0) {
                ipip.ipip_zoneid = z;
                ipip.ipip_arg = icp->ic_drop;
                if (ioctl(fd, IPDIOC_DROP, &ipip) != 0) {
                        return (ipd_set_errno(xlate_errno(errno),
                            "unable to set drop probability to %d: %s",
                            ipip.ipip_arg, strerror(errno)));
                }
        }

        return (0);
}