/*
 * 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 2015, Joyent, Inc.
 */

/*
 * Files based plug-in for varpd
 *
 * This is a dynamic varpd plug-in that has a static backing store. It's really
 * nothing more than a glorified version of /etc/ethers, though it facilitates
 * a bit more. The files module allows for the full set of mappings to be fixed
 * at creation time. In addition, it also provides support for proxying ARP,
 * NDP, and DHCP.
 *
 * At this time, the plugin requires that the destination type involve both an
 * IP address and a port; however, there's no reason that this cannot be made
 * more flexible as we have additional encapsulation algorithms that support it.
 * The plug-in only has a single property, which is the location of the JSON
 * file. The JSON file itself looks something like:
 *
 *      {
 *              "aa:bb:cc:dd:ee:ff": {
 *                      "arp": "10.23.69.1",
 *                      "ndp": "2600:3c00::f03c:91ff:fe96:a264",
 *                      "ip": "192.168.1.1",
 *                      "port": 8080
 *              },
 *              ...
 *      }
 */

#include <libvarpd_provider.h>
#include <umem.h>
#include <errno.h>
#include <thread.h>
#include <synch.h>
#include <strings.h>
#include <assert.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <libnvpair.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/ethernet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <libvarpd_files_json.h>

typedef struct varpd_files {
        overlay_plugin_dest_t   vaf_dest;       /* RO */
        varpd_provider_handle_t *vaf_hdl;       /* RO */
        char                    *vaf_path;      /* WO */
        nvlist_t                *vaf_nvl;       /* WO */
        uint64_t                vaf_nmisses;    /* Atomic */
        uint64_t                vaf_narp;       /* Atomic */
} varpd_files_t;

static const char *varpd_files_props[] = {
        "files/config"
};

static boolean_t
varpd_files_valid_dest(overlay_plugin_dest_t dest)
{
        if (dest & ~(OVERLAY_PLUGIN_D_IP | OVERLAY_PLUGIN_D_PORT))
                return (B_FALSE);

        if (!(dest & (OVERLAY_PLUGIN_D_IP | OVERLAY_PLUGIN_D_PORT)))
                return (B_FALSE);

        return (B_TRUE);
}

static int
varpd_files_create(varpd_provider_handle_t *hdl, void **outp,
    overlay_plugin_dest_t dest)
{
        varpd_files_t *vaf;

        if (varpd_files_valid_dest(dest) == B_FALSE)
                return (ENOTSUP);

        vaf = umem_alloc(sizeof (varpd_files_t), UMEM_DEFAULT);
        if (vaf == NULL)
                return (ENOMEM);

        bzero(vaf, sizeof (varpd_files_t));
        vaf->vaf_dest = dest;
        vaf->vaf_path = NULL;
        vaf->vaf_nvl = NULL;
        vaf->vaf_hdl = hdl;
        *outp = vaf;
        return (0);
}

static int
varpd_files_normalize_nvlist(varpd_files_t *vaf, nvlist_t *nvl)
{
        int ret;
        nvlist_t *out;
        nvpair_t *pair;

        if ((ret = nvlist_alloc(&out, NV_UNIQUE_NAME, 0)) != 0)
                return (ret);

        for (pair = nvlist_next_nvpair(nvl, NULL); pair != NULL;
            pair = nvlist_next_nvpair(nvl, pair)) {
                char *name, fname[ETHERADDRSTRL];
                nvlist_t *data;
                struct ether_addr ether, *e;
                e = &ether;

                if (nvpair_type(pair) != DATA_TYPE_NVLIST) {
                        nvlist_free(out);
                        return (EINVAL);
                }

                name = nvpair_name(pair);
                if ((ret = nvpair_value_nvlist(pair, &data)) != 0) {
                        nvlist_free(out);
                        return (EINVAL);
                }

                if (ether_aton_r(name, e) == NULL) {
                        nvlist_free(out);
                        return (EINVAL);
                }

                if (ether_ntoa_r(e, fname) == NULL) {
                        nvlist_free(out);
                        return (ENOMEM);
                }

                if ((ret = nvlist_add_nvlist(out, fname, data)) != 0) {
                        nvlist_free(out);
                        return (EINVAL);
                }
        }

        vaf->vaf_nvl = out;
        return (0);
}

static int
varpd_files_start(void *arg)
{
        int fd, ret;
        void *maddr;
        struct stat st;
        nvlist_t *nvl;
        varpd_files_t *vaf = arg;

        if (vaf->vaf_path == NULL)
                return (EAGAIN);

        if ((fd = open(vaf->vaf_path, O_RDONLY)) < 0)
                return (errno);

        if (fstat(fd, &st) != 0) {
                ret = errno;
                if (close(fd) != 0)
                        abort();
                return (ret);
        }

        maddr = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
            fd, 0);
        if (maddr == NULL) {
                ret = errno;
                if (close(fd) != 0)
                        abort();
                return (ret);
        }

        ret = nvlist_parse_json(maddr, st.st_size, &nvl,
            NVJSON_FORCE_INTEGER, NULL);
        if (ret == 0) {
                ret = varpd_files_normalize_nvlist(vaf, nvl);
                nvlist_free(nvl);
        }
        if (munmap(maddr, st.st_size) != 0)
                abort();
        if (close(fd) != 0)
                abort();

        return (ret);
}

static void
varpd_files_stop(void *arg)
{
        varpd_files_t *vaf = arg;

        nvlist_free(vaf->vaf_nvl);
        vaf->vaf_nvl = NULL;
}

static void
varpd_files_destroy(void *arg)
{
        varpd_files_t *vaf = arg;

        assert(vaf->vaf_nvl == NULL);
        if (vaf->vaf_path != NULL) {
                umem_free(vaf->vaf_path, strlen(vaf->vaf_path) + 1);
                vaf->vaf_path = NULL;
        }
        umem_free(vaf, sizeof (varpd_files_t));
}

static void
varpd_files_lookup(void *arg, varpd_query_handle_t *qh,
    const overlay_targ_lookup_t *otl, overlay_target_point_t *otp)
{
        char macstr[ETHERADDRSTRL], *ipstr;
        nvlist_t *nvl;
        varpd_files_t *vaf = arg;
        int32_t port;
        static const uint8_t bcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

        /* We don't support a default */
        if (otl == NULL) {
                libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                return;
        }

        if (otl->otl_sap == ETHERTYPE_ARP) {
                libvarpd_plugin_proxy_arp(vaf->vaf_hdl, qh, otl);
                return;
        }

        if (otl->otl_sap == ETHERTYPE_IPV6 &&
            otl->otl_dstaddr[0] == 0x33 &&
            otl->otl_dstaddr[1] == 0x33) {
                libvarpd_plugin_proxy_ndp(vaf->vaf_hdl, qh, otl);
                return;
        }

        if (otl->otl_sap == ETHERTYPE_IP &&
            bcmp(otl->otl_dstaddr, bcast, ETHERADDRL) == 0) {
                char *mac;
                struct ether_addr a, *addr;

                addr = &a;
                if (ether_ntoa_r((struct ether_addr *)otl->otl_srcaddr,
                    macstr) == NULL) {
                        libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                        return;
                }

                if (nvlist_lookup_nvlist(vaf->vaf_nvl, macstr, &nvl) != 0) {
                        libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                        return;
                }

                if (nvlist_lookup_string(nvl, "dhcp-proxy", &mac) != 0) {
                        libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                        return;
                }

                if (ether_aton_r(mac, addr) == NULL) {
                        libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                        return;
                }

                libvarpd_plugin_proxy_dhcp(vaf->vaf_hdl, qh, otl);
                return;
        }

        if (ether_ntoa_r((struct ether_addr *)otl->otl_dstaddr,
            macstr) == NULL) {
                libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                return;
        }

        if (nvlist_lookup_nvlist(vaf->vaf_nvl, macstr, &nvl) != 0) {
                libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                return;
        }

        if (nvlist_lookup_int32(nvl, "port", &port) != 0) {
                libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                return;
        }

        if (port <= 0 || port > UINT16_MAX) {
                libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                return;
        }
        otp->otp_port = port;

        if (nvlist_lookup_string(nvl, "ip", &ipstr) != 0) {
                libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                return;
        }

        /*
         * Try to parse it as a v6 address and then if it's not, try to
         * transform it into a v4 address which we'll then wrap it into a v4
         * mapped address.
         */
        if (inet_pton(AF_INET6, ipstr, &otp->otp_ip) != 1) {
                uint32_t v4;
                if (inet_pton(AF_INET, ipstr, &v4) != 1) {
                        libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_DROP);
                        return;
                }
                IN6_IPADDR_TO_V4MAPPED(v4, &otp->otp_ip);
        }

        libvarpd_plugin_query_reply(qh, VARPD_LOOKUP_OK);
}

/* ARGSUSED */
static int
varpd_files_nprops(void *arg, uint_t *nprops)
{
        *nprops = 1;
        return (0);
}

/* ARGSUSED */
static int
varpd_files_propinfo(void *arg, uint_t propid, varpd_prop_handle_t *vph)
{
        if (propid != 0)
                return (EINVAL);

        libvarpd_prop_set_name(vph, varpd_files_props[0]);
        libvarpd_prop_set_prot(vph, OVERLAY_PROP_PERM_RRW);
        libvarpd_prop_set_type(vph, OVERLAY_PROP_T_STRING);
        libvarpd_prop_set_nodefault(vph);
        return (0);
}

static int
varpd_files_getprop(void *arg, const char *pname, void *buf, uint32_t *sizep)
{
        varpd_files_t *vaf = arg;

        if (strcmp(pname, varpd_files_props[0]) != 0)
                return (EINVAL);

        if (vaf->vaf_path != NULL) {
                size_t len = strlen(vaf->vaf_path) + 1;
                if (*sizep < len)
                        return (EOVERFLOW);
                *sizep = len;
                (void) strlcpy(buf, vaf->vaf_path, *sizep);

        } else {
                *sizep = 0;
        }

        return (0);
}

static int
varpd_files_setprop(void *arg, const char *pname, const void *buf,
    const uint32_t size)
{
        varpd_files_t *vaf = arg;

        if (strcmp(pname, varpd_files_props[0]) != 0)
                return (EINVAL);

        if (vaf->vaf_path != NULL)
                umem_free(vaf->vaf_path, strlen(vaf->vaf_path) + 1);

        vaf->vaf_path = umem_alloc(size, UMEM_DEFAULT);
        if (vaf->vaf_path == NULL)
                return (ENOMEM);
        (void) strlcpy(vaf->vaf_path, buf, size);
        return (0);
}

static int
varpd_files_save(void *arg, nvlist_t *nvp)
{
        int ret;
        varpd_files_t *vaf = arg;

        if (vaf->vaf_path == NULL)
                return (0);

        if ((ret = nvlist_add_string(nvp, varpd_files_props[0],
            vaf->vaf_path)) != 0)
                return (ret);

        if ((ret = nvlist_add_uint64(nvp, "files/vaf_nmisses",
            vaf->vaf_nmisses)) != 0)
                return (ret);

        if ((ret = nvlist_add_uint64(nvp, "files/vaf_narp",
            vaf->vaf_narp)) != 0)
                return (ret);
        return (0);
}

static int
varpd_files_restore(nvlist_t *nvp, varpd_provider_handle_t *hdl,
    overlay_plugin_dest_t dest, void **outp)
{
        varpd_files_t *vaf;
        char *str;
        int ret;
        uint64_t nmisses, narp;

        if (varpd_files_valid_dest(dest) == B_FALSE)
                return (EINVAL);

        ret = nvlist_lookup_string(nvp, varpd_files_props[0], &str);
        if (ret != 0 && ret != ENOENT)
                return (ret);
        else if (ret == ENOENT)
                str = NULL;

        if (nvlist_lookup_uint64(nvp, "files/vaf_nmisses", &nmisses) != 0)
                return (EINVAL);
        if (nvlist_lookup_uint64(nvp, "files/vaf_narp", &narp) != 0)
                return (EINVAL);

        vaf = umem_alloc(sizeof (varpd_files_t), UMEM_DEFAULT);
        if (vaf == NULL)
                return (ENOMEM);

        bzero(vaf, sizeof (varpd_files_t));
        vaf->vaf_dest = dest;
        if (str != NULL) {
                size_t len = strlen(str) + 1;
                vaf->vaf_path = umem_alloc(len, UMEM_DEFAULT);
                if (vaf->vaf_path == NULL) {
                        umem_free(vaf, sizeof (varpd_files_t));
                        return (ENOMEM);
                }
                (void) strlcpy(vaf->vaf_path, str, len);
        }

        vaf->vaf_hdl = hdl;
        *outp = vaf;
        return (0);
}

static void
varpd_files_proxy_arp(void *arg, varpd_arp_handle_t *vah, int kind,
    const struct sockaddr *sock, uint8_t *out)
{
        varpd_files_t *vaf = arg;
        const struct sockaddr_in *ip;
        const struct sockaddr_in6 *ip6;
        nvpair_t *pair;

        if (kind != VARPD_QTYPE_ETHERNET) {
                libvarpd_plugin_arp_reply(vah, VARPD_LOOKUP_DROP);
                return;
        }

        if (sock->sa_family != AF_INET && sock->sa_family != AF_INET6) {
                libvarpd_plugin_arp_reply(vah, VARPD_LOOKUP_DROP);
                return;
        }

        ip = (const struct sockaddr_in *)sock;
        ip6 = (const struct sockaddr_in6 *)sock;
        for (pair = nvlist_next_nvpair(vaf->vaf_nvl, NULL); pair != NULL;
            pair = nvlist_next_nvpair(vaf->vaf_nvl, pair)) {
                char *mac, *ipstr;
                nvlist_t *data;
                struct in_addr ia;
                struct in6_addr ia6;
                struct ether_addr ether, *e;
                e = &ether;

                if (nvpair_type(pair) != DATA_TYPE_NVLIST)
                        continue;

                mac = nvpair_name(pair);
                if (nvpair_value_nvlist(pair, &data) != 0)
                        continue;


                if (sock->sa_family == AF_INET) {
                        if (nvlist_lookup_string(data, "arp", &ipstr) != 0)
                                continue;

                        if (inet_pton(AF_INET, ipstr, &ia) != 1)
                                continue;

                        if (bcmp(&ia, &ip->sin_addr,
                            sizeof (struct in_addr)) != 0)
                                continue;
                } else {
                        if (nvlist_lookup_string(data, "ndp", &ipstr) != 0)
                                continue;

                        if (inet_pton(AF_INET6, ipstr, &ia6) != 1)
                                continue;

                        if (bcmp(&ia6, &ip6->sin6_addr,
                            sizeof (struct in6_addr)) != 0)
                                continue;
                }

                if (ether_aton_r(mac, e) == NULL) {
                        libvarpd_plugin_arp_reply(vah, VARPD_LOOKUP_DROP);
                        return;
                }

                bcopy(e, out, ETHERADDRL);
                libvarpd_plugin_arp_reply(vah, VARPD_LOOKUP_OK);
                return;
        }

        libvarpd_plugin_arp_reply(vah, VARPD_LOOKUP_DROP);
}

static void
varpd_files_proxy_dhcp(void *arg, varpd_dhcp_handle_t *vdh, int type,
    const overlay_targ_lookup_t *otl, uint8_t *out)
{
        varpd_files_t *vaf = arg;
        nvlist_t *nvl;
        char macstr[ETHERADDRSTRL], *mac;
        struct ether_addr a, *addr;

        addr = &a;
        if (type != VARPD_QTYPE_ETHERNET) {
                libvarpd_plugin_dhcp_reply(vdh, VARPD_LOOKUP_DROP);
                return;
        }

        if (ether_ntoa_r((struct ether_addr *)otl->otl_srcaddr,
            macstr) == NULL) {
                libvarpd_plugin_dhcp_reply(vdh, VARPD_LOOKUP_DROP);
                return;
        }

        if (nvlist_lookup_nvlist(vaf->vaf_nvl, macstr, &nvl) != 0) {
                libvarpd_plugin_dhcp_reply(vdh, VARPD_LOOKUP_DROP);
                return;
        }

        if (nvlist_lookup_string(nvl, "dhcp-proxy", &mac) != 0) {
                libvarpd_plugin_dhcp_reply(vdh, VARPD_LOOKUP_DROP);
                return;
        }

        if (ether_aton_r(mac, addr) == NULL) {
                libvarpd_plugin_dhcp_reply(vdh, VARPD_LOOKUP_DROP);
                return;
        }

        bcopy(addr, out, ETHERADDRL);
        libvarpd_plugin_dhcp_reply(vdh, VARPD_LOOKUP_OK);
}

static const varpd_plugin_ops_t varpd_files_ops = {
        0,
        varpd_files_create,
        varpd_files_start,
        varpd_files_stop,
        varpd_files_destroy,
        NULL,
        varpd_files_lookup,
        varpd_files_nprops,
        varpd_files_propinfo,
        varpd_files_getprop,
        varpd_files_setprop,
        varpd_files_save,
        varpd_files_restore,
        varpd_files_proxy_arp,
        varpd_files_proxy_dhcp
};

#pragma init(varpd_files_init)
static void
varpd_files_init(void)
{
        int err;
        varpd_plugin_register_t *vpr;

        vpr = libvarpd_plugin_alloc(VARPD_CURRENT_VERSION, &err);
        if (vpr == NULL)
                return;

        vpr->vpr_mode = OVERLAY_TARGET_DYNAMIC;
        vpr->vpr_name = "files";
        vpr->vpr_ops = &varpd_files_ops;
        (void) libvarpd_plugin_register(vpr);
        libvarpd_plugin_free(vpr);
}