/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2025-2026 Pouria Mousavizadeh Tehrani <pouria@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/nv.h>
#include <sys/socket.h>
#include <sys/sockio.h>

#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <netdb.h>

#include <net/ethernet.h>
#include <net/if.h>
#include <net/if_strings.h>
#include <netinet/in.h>
#include <net/if_geneve.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <errno.h>

#include "ifconfig.h"
#include "ifconfig_netlink.h"

struct nl_parsed_geneve {
        /* essential */
        uint32_t                        ifla_vni;
        uint16_t                        ifla_proto;
        struct sockaddr                 *ifla_local;
        struct sockaddr                 *ifla_remote;
        uint16_t                        ifla_local_port;
        uint16_t                        ifla_remote_port;

        /* optional */
        struct ifla_geneve_port_range   *ifla_port_range;
        enum ifla_geneve_df             ifla_df;
        uint8_t                         ifla_ttl;
        bool                            ifla_ttl_inherit;
        bool                            ifla_dscp_inherit;
        bool                            ifla_external;

        /* l2 specific */
        bool                            ifla_ftable_learn;
        bool                            ifla_ftable_flush;
        uint32_t                        ifla_ftable_max;
        uint32_t                        ifla_ftable_timeout;
        uint32_t                        ifla_ftable_count;
        uint32_t                        ifla_ftable_nospace;
        uint32_t                        ifla_ftable_lock_upgrade_failed;

        /* multicast specific */
        char                            *ifla_mc_ifname;
        uint32_t                        ifla_mc_ifindex;

        /* csum info */
        uint64_t                        ifla_stats_txcsum;
        uint64_t                        ifla_stats_tso;
        uint64_t                        ifla_stats_rxcsum;
};

static struct geneve_params gnvp = {
        .ifla_proto             =       GENEVE_PROTO_ETHER,
};

static int
get_proto(const char *cp, uint16_t *valp)
{
        uint16_t val;

        if (!strcmp(cp, "l2"))
                val = GENEVE_PROTO_ETHER;
        else if (!strcmp(cp, "l3"))
                val = GENEVE_PROTO_INHERIT;
        else
                return (-1);

        *valp = val;
        return (0);
}

static int
get_val(const char *cp, u_long *valp)
{
        char *endptr;
        u_long val;

        errno = 0;
        val = strtoul(cp, &endptr, 0);
        if (cp[0] == '\0' || endptr[0] != '\0' || errno == ERANGE)
                return (-1);

        *valp = val;
        return (0);
}

static int
get_df(const char *cp, enum ifla_geneve_df *valp)
{
        enum ifla_geneve_df df;

        if (!strcmp(cp, "set"))
                df = IFLA_GENEVE_DF_SET;
        else if (!strcmp(cp, "inherit"))
                df = IFLA_GENEVE_DF_INHERIT;
        else if (!strcmp(cp, "unset"))
                df = IFLA_GENEVE_DF_UNSET;
        else
                return (-1);

        *valp = df;
        return (0);
}

static bool
is_multicast(struct addrinfo *ai)
{
#if (defined INET || defined INET6)
        struct sockaddr *sa;
        sa = ai->ai_addr;
#endif

        switch (ai->ai_family) {
#ifdef INET
        case AF_INET: {
                struct sockaddr_in *sin = satosin(sa);

                return (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)));
        }
#endif
#ifdef INET6
        case AF_INET6: {
                struct sockaddr_in6 *sin6 = satosin6(sa);

                return (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr));
        }
#endif
        default:
                errx(1, "address family not supported");
        }
}

/*
 * geneve mode is read-only after creation,
 * therefore there is no need for separate netlink implementation
 */
static void
setgeneve_mode_clone(if_ctx *ctx __unused, const char *arg, int dummy __unused)
{
        uint16_t val;

        if (get_proto(arg, &val) < 0)
                errx(1, "invalid inner protocol: %s", arg);

        gnvp.ifla_proto = val;
}

struct nla_geneve_info {
        const char              *kind;
        struct nl_parsed_geneve data;
};

struct nla_geneve_link {
        uint32_t                ifi_index;
        struct nla_geneve_info  linkinfo;
};

static inline void
geneve_nl_init(if_ctx *ctx, struct snl_writer *nw, uint32_t flags)
{
        struct nlmsghdr *hdr;

        snl_init_writer(ctx->io_ss, nw);
        hdr = snl_create_msg_request(nw, NL_RTM_NEWLINK);
        hdr->nlmsg_flags |= flags;
        snl_reserve_msg_object(nw, struct ifinfomsg);
        snl_add_msg_attr_string(nw, IFLA_IFNAME, ctx->ifname);
}

static inline void
geneve_nl_fini(if_ctx *ctx, struct snl_writer *nw)
{
        struct nlmsghdr *hdr;
        struct snl_errmsg_data errmsg = {};

        hdr = snl_finalize_msg(nw);
        if (hdr == NULL || !snl_send_message(ctx->io_ss, hdr))
                err(1, "unable to send netlink message");

        if (!snl_read_reply_code(ctx->io_ss, hdr->nlmsg_seq, &errmsg))
                errx(errmsg.error, "%s", errmsg.error_str);
}

#define _OUT(_field)    offsetof(struct nl_parsed_geneve, _field)
static const struct snl_attr_parser nla_geneve_linkinfo_data[] = {
        { .type = IFLA_GENEVE_ID, .off = _OUT(ifla_vni), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_PROTOCOL, .off = _OUT(ifla_proto), .cb = snl_attr_get_uint16 },
        { .type = IFLA_GENEVE_LOCAL, .off = _OUT(ifla_local), .cb = snl_attr_get_ip },
        { .type = IFLA_GENEVE_REMOTE, .off = _OUT(ifla_remote), .cb = snl_attr_get_ip },
        { .type = IFLA_GENEVE_LOCAL_PORT, .off = _OUT(ifla_local_port), .cb = snl_attr_get_uint16 },
        { .type = IFLA_GENEVE_PORT, .off = _OUT(ifla_remote_port), .cb = snl_attr_get_uint16 },
        { .type = IFLA_GENEVE_PORT_RANGE, .off = _OUT(ifla_port_range), .cb = snl_attr_dup_struct },
        { .type = IFLA_GENEVE_DF, .off = _OUT(ifla_df), .cb = snl_attr_get_uint8 },
        { .type = IFLA_GENEVE_TTL, .off = _OUT(ifla_ttl), .cb = snl_attr_get_uint8 },
        { .type = IFLA_GENEVE_TTL_INHERIT, .off = _OUT(ifla_ttl_inherit), .cb = snl_attr_get_bool },
        { .type = IFLA_GENEVE_DSCP_INHERIT, .off = _OUT(ifla_dscp_inherit), .cb = snl_attr_get_bool },
        { .type = IFLA_GENEVE_COLLECT_METADATA, .off = _OUT(ifla_external), .cb = snl_attr_get_bool },
        { .type = IFLA_GENEVE_FTABLE_LEARN, .off = _OUT(ifla_ftable_learn), .cb = snl_attr_get_bool },
        { .type = IFLA_GENEVE_FTABLE_FLUSH, .off = _OUT(ifla_ftable_flush), .cb = snl_attr_get_bool },
        { .type = IFLA_GENEVE_FTABLE_MAX, .off = _OUT(ifla_ftable_max), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_FTABLE_TIMEOUT, .off = _OUT(ifla_ftable_timeout), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_FTABLE_COUNT, .off = _OUT(ifla_ftable_count), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_FTABLE_NOSPACE_CNT, .off = _OUT(ifla_ftable_nospace), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_FTABLE_LOCK_UP_FAIL_CNT, .off = _OUT(ifla_ftable_lock_upgrade_failed), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_MC_IFNAME, .off = _OUT(ifla_mc_ifname), .cb = snl_attr_get_string },
        { .type = IFLA_GENEVE_MC_IFINDEX, .off = _OUT(ifla_mc_ifindex), .cb = snl_attr_get_uint32 },
        { .type = IFLA_GENEVE_TXCSUM_CNT, .off = _OUT(ifla_stats_txcsum), .cb = snl_attr_get_uint64 },
        { .type = IFLA_GENEVE_TSO_CNT, .off = _OUT(ifla_stats_tso), .cb = snl_attr_get_uint64 },
        { .type = IFLA_GENEVE_RXCSUM_CNT, .off = _OUT(ifla_stats_rxcsum), .cb = snl_attr_get_uint64 },
};
#undef _OUT
SNL_DECLARE_ATTR_PARSER(geneve_linkinfo_data_parser, nla_geneve_linkinfo_data);

#define _OUT(_field)    offsetof(struct nla_geneve_info, _field)
static const struct snl_attr_parser ap_geneve_linkinfo[] = {
        { .type = IFLA_INFO_KIND, .off = _OUT(kind), .cb = snl_attr_get_string },
        { .type = IFLA_INFO_DATA, .off = _OUT(data),
                .arg = &geneve_linkinfo_data_parser, .cb = snl_attr_get_nested },
};
#undef _OUT
SNL_DECLARE_ATTR_PARSER(geneve_linkinfo_parser, ap_geneve_linkinfo);

#define _IN(_field)     offsetof(struct ifinfomsg, _field)
#define _OUT(_field)    offsetof(struct nla_geneve_link, _field)
static const struct snl_attr_parser ap_geneve_link[] = {
        { .type = IFLA_LINKINFO, .off = _OUT(linkinfo),
                .arg = &geneve_linkinfo_parser, .cb = snl_attr_get_nested },
};

static const struct snl_field_parser fp_geneve_link[] = {
        { .off_in = _IN(ifi_index), .off_out = _OUT(ifi_index), .cb = snl_field_get_uint32 },
};
#undef _IN
#undef _OUT
SNL_DECLARE_PARSER(geneve_parser, struct ifinfomsg, fp_geneve_link, ap_geneve_link);

static const struct snl_hdr_parser *all_parsers[] = {
        &geneve_linkinfo_data_parser,
        &geneve_linkinfo_parser,
        &geneve_parser,
};

static void
geneve_status_nl(if_ctx *ctx)
{
        struct snl_writer nw;
        struct nlmsghdr *hdr;
        struct snl_errmsg_data errmsg;
        struct nla_geneve_link geneve_link = {0};
        char src[INET6_ADDRSTRLEN], dst[INET6_ADDRSTRLEN];
        struct sockaddr *lsa, *rsa;
        int mc;
        bool ipv6 = false;

        if (strncmp(ctx->ifname, "geneve", sizeof("geneve") - 1) != 0)
                return;

        snl_init_writer(ctx->io_ss, &nw);
        hdr = snl_create_msg_request(&nw, NL_RTM_GETLINK);
        hdr->nlmsg_flags |= NLM_F_DUMP;
        snl_reserve_msg_object(&nw, struct ifinfomsg);
        snl_add_msg_attr_string(&nw, IFLA_IFNAME, ctx->ifname);

        if (!(hdr = snl_finalize_msg(&nw)) || (!snl_send_message(ctx->io_ss, hdr)))
                return;

        hdr = snl_read_reply(ctx->io_ss, hdr->nlmsg_seq);
        if (hdr->nlmsg_type != NL_RTM_NEWLINK) {
                if (!snl_parse_errmsg(ctx->io_ss, hdr, &errmsg))
                        errx(EINVAL, "(NETLINK)");
                if (errmsg.error_str != NULL)
                        errx(errmsg.error, "(NETLINK) %s", errmsg.error_str);
        }

        if (!snl_parse_nlmsg(ctx->io_ss, hdr, &geneve_parser, &geneve_link))
                return;

        struct nla_geneve_info geneve_info = geneve_link.linkinfo;
        struct nl_parsed_geneve geneve_data = geneve_info.data;

        printf("\tgeneve mode: ");
        switch (geneve_data.ifla_proto) {
        case GENEVE_PROTO_INHERIT:
                printf("l3");
                break;
        case GENEVE_PROTO_ETHER:
        default:
                printf("l2");
                break;
        }

        printf("\n\tgeneve config:\n");
        /* Just report nothing if the network identity isn't set yet. */
        if (geneve_data.ifla_vni >= GENEVE_VNI_MAX) {
                printf("\t\tvirtual network identifier (vni): not configured\n");
                return;
        }

        lsa = geneve_data.ifla_local;
        rsa = geneve_data.ifla_remote;

        if ((lsa == NULL) ||
            (getnameinfo(lsa, lsa->sa_len, src, sizeof(src),
            NULL, 0, NI_NUMERICHOST) != 0))
                src[0] = '\0';
        if ((rsa == NULL) ||
            (getnameinfo(rsa, rsa->sa_len, dst, sizeof(dst),
            NULL, 0, NI_NUMERICHOST) != 0))
                dst[0] = '\0';
        else {
                ipv6 = rsa->sa_family == AF_INET6;
                if (!ipv6) {
                        struct sockaddr_in *sin = satosin(rsa);
                        mc = IN_MULTICAST(ntohl(sin->sin_addr.s_addr));
                } else {
                        struct sockaddr_in6 *sin6 = satosin6(rsa);
                        mc = IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr);
                }
        }

        printf("\t\tvirtual network identifier (vni): %d", geneve_data.ifla_vni);
        if (src[0] != '\0')
                printf("\n\t\tlocal: %s%s%s:%u", ipv6 ? "[" : "", src, ipv6 ? "]" : "",
                    geneve_data.ifla_local_port);
        if (dst[0] != '\0') {
                printf("\n\t\t%s: %s%s%s:%u", mc ? "group" : "remote", ipv6 ? "[" : "",
                    dst, ipv6 ? "]" : "", geneve_data.ifla_local_port);
                if (mc)
                        printf(", dev: %s", geneve_data.ifla_mc_ifname);
        }

        if (ctx->args->verbose) {
                printf("\n\t\tportrange: %u-%u",
                    geneve_data.ifla_port_range->low,
                    geneve_data.ifla_port_range->high);

                if (geneve_data.ifla_ttl_inherit)
                        printf(", ttl: inherit");
                else
                        printf(", ttl: %d", geneve_data.ifla_ttl);

                if (geneve_data.ifla_dscp_inherit)
                        printf(", dscp: inherit");

                if (geneve_data.ifla_df == IFLA_GENEVE_DF_INHERIT)
                        printf(", df: inherit");
                else if (geneve_data.ifla_df == IFLA_GENEVE_DF_SET)
                        printf(", df: set");
                else if (geneve_data.ifla_df == IFLA_GENEVE_DF_UNSET)
                        printf(", df: unset");

                if (geneve_data.ifla_external)
                        printf(", externally controlled");

                if (geneve_data.ifla_proto == GENEVE_PROTO_ETHER) {
                        printf("\n\t\tftable mode: %slearning",
                            geneve_data.ifla_ftable_learn ? "" : "no");
                        printf(", count: %d, max: %d, timeout: %d",
                            geneve_data.ifla_ftable_count,
                            geneve_data.ifla_ftable_max,
                            geneve_data.ifla_ftable_timeout);
                        printf(", nospace: %u",
                            geneve_data.ifla_ftable_nospace);
                }

                printf("\n\t\tstats: tso %ju, txcsum %ju, rxcsum %ju",
                    (uintmax_t)geneve_data.ifla_stats_tso,
                    (uintmax_t)geneve_data.ifla_stats_txcsum,
                    (uintmax_t)geneve_data.ifla_stats_rxcsum);
        }

        putchar('\n');
}


static void
geneve_create_nl(if_ctx *ctx, struct ifreq *ifr)
{
        struct snl_writer nw = {};
        struct nlmsghdr *hdr;
        int off, off2;

        snl_init_writer(ctx->io_ss, &nw);
        hdr = snl_create_msg_request(&nw, RTM_NEWLINK);
        hdr->nlmsg_flags |= (NLM_F_CREATE | NLM_F_EXCL);
        snl_reserve_msg_object(&nw, struct ifinfomsg);
        snl_add_msg_attr_string(&nw, IFLA_IFNAME, ifr->ifr_name);

        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);
        snl_add_msg_attr_u16(&nw, IFLA_GENEVE_PROTOCOL, gnvp.ifla_proto);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_vni_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long val;

        if (get_val(arg, &val) < 0 || val >= GENEVE_VNI_MAX)
                errx(1, "invalid network identifier: %s", arg);

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);
        snl_add_msg_attr_u32(&nw, IFLA_GENEVE_ID, val);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_local_nl(if_ctx *ctx, const char *addr, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        struct addrinfo *ai;
        const struct sockaddr *sa;
        int error;

        if ((error = getaddrinfo(addr, NULL, NULL, &ai)) != 0)
                errx(1, "error in parsing local address string: %s",
                    gai_strerror(error));

        if (is_multicast(ai))
                errx(1, "local address cannot be multicast");

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        sa = ai->ai_addr;
        snl_add_msg_attr_ip(&nw, IFLA_GENEVE_LOCAL, sa);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_remote_nl(if_ctx *ctx, const char *addr, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        struct addrinfo *ai;
        const struct sockaddr *sa;
        int error;

        if ((error = getaddrinfo(addr, NULL, NULL, &ai)) != 0)
                errx(1, "error in parsing remote address string: %s",
                    gai_strerror(error));

        if (is_multicast(ai))
                errx(1, "remote address cannot be multicast");

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        sa = ai->ai_addr;
        snl_add_msg_attr_ip(&nw, IFLA_GENEVE_REMOTE, sa);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_group_nl(if_ctx *ctx, const char *addr, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        struct addrinfo *ai;
        struct sockaddr *sa;
        int error;

        if ((error = getaddrinfo(addr, NULL, NULL, &ai)) != 0)
                errx(1, "error in parsing local address string: %s",
                    gai_strerror(error));

        if (!is_multicast(ai))
                errx(1, "group address must be multicast");

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        sa = ai->ai_addr;
        snl_add_msg_attr_ip(&nw, IFLA_GENEVE_REMOTE, sa);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}


static void
setgeneve_local_port_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long val;

        if (get_val(arg, &val) < 0 || val >= UINT16_MAX)
                errx(1, "invalid local port: %s", arg);

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_u16(&nw, IFLA_GENEVE_LOCAL_PORT, val);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_remote_port_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long val;

        if (get_val(arg, &val) < 0 || val >= UINT16_MAX)
                errx(1, "invalid remote port: %s", arg);

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_u16(&nw, IFLA_GENEVE_PORT, val);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_port_range_nl(if_ctx *ctx, const char *arg1, const char *arg2)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long min, max;

        if (get_val(arg1, &min) < 0 || min >= UINT16_MAX)
                errx(1, "invalid port range minimum: %s", arg1);
        if (get_val(arg2, &max) < 0 || max >= UINT16_MAX)
                errx(1, "invalid port range maximum: %s", arg2);
        if (max < min)
                errx(1, "invalid port range");

        const struct ifla_geneve_port_range port_range = {
                .low = min,
                .high = max
        };

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr(&nw, IFLA_GENEVE_PORT_RANGE,
                        sizeof(port_range), (const void *)&port_range);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_timeout_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long val;

        if (get_val(arg, &val) < 0 || (val & ~0xFFFFFFFF) != 0)
                errx(1, "invalid timeout value: %s", arg);

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_u32(&nw, IFLA_GENEVE_FTABLE_TIMEOUT, val);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_maxaddr_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long val;

        if (get_val(arg, &val) < 0 || (val & ~0xFFFFFFFF) != 0)
                errx(1, "invalid maxaddr value: %s",  arg);

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_u32(&nw, IFLA_GENEVE_FTABLE_MAX, val);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_dev_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_string(&nw, IFLA_GENEVE_MC_IFNAME, arg);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_ttl_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        u_long val;

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);
        if ((get_val(arg, &val) < 0 || val > 256) == 0) {
                snl_add_msg_attr_u8(&nw, IFLA_GENEVE_TTL, val);
                snl_add_msg_attr_bool(&nw, IFLA_GENEVE_TTL_INHERIT, false);
        } else if (!strcmp(arg, "inherit")) {
                snl_add_msg_attr_bool(&nw, IFLA_GENEVE_TTL_INHERIT, true);
        } else
                errx(1, "invalid TTL value: %s", arg);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_df_nl(if_ctx *ctx, const char *arg, int dummy __unused)
{
        struct snl_writer nw = {};
        int off, off2;
        enum ifla_geneve_df df;

        if (get_df(arg, &df) < 0)
                errx(1, "invalid df value: %s", arg);

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_u8(&nw, IFLA_GENEVE_DF, df);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_inherit_dscp_nl(if_ctx *ctx, const char *arg __unused, int d)
{
        struct snl_writer nw = {};
        int off, off2;

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_bool(&nw, IFLA_GENEVE_DSCP_INHERIT, d != 0);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_learn_nl(if_ctx *ctx, const char *arg __unused, int d)
{
        struct snl_writer nw = {};
        int off, off2;

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_bool(&nw, IFLA_GENEVE_FTABLE_LEARN, d != 0);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_flush_nl(if_ctx *ctx, const char *val __unused, int d)
{
        struct snl_writer nw = {};
        int off, off2;

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_bool(&nw, IFLA_GENEVE_FTABLE_FLUSH, d != 0);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static void
setgeneve_external_nl(if_ctx *ctx, const char *val __unused, int d)
{
        struct snl_writer nw = {};
        int off, off2;

        geneve_nl_init(ctx, &nw, 0);
        off = snl_add_msg_attr_nested(&nw, IFLA_LINKINFO);
        snl_add_msg_attr_string(&nw, IFLA_INFO_KIND, "geneve");

        off2 = snl_add_msg_attr_nested(&nw, IFLA_INFO_DATA);

        snl_add_msg_attr_bool(&nw, IFLA_GENEVE_COLLECT_METADATA, d != 0);

        snl_end_attr_nested(&nw, off2);
        snl_end_attr_nested(&nw, off);

        geneve_nl_fini(ctx, &nw);
}

static struct cmd geneve_cmds[] = {

        DEF_CLONE_CMD_ARG("genevemode",         setgeneve_mode_clone),

        DEF_CMD_ARG("geneveid",                 setgeneve_vni_nl),
        DEF_CMD_ARG("genevelocal",              setgeneve_local_nl),
        DEF_CMD_ARG("geneveremote",             setgeneve_remote_nl),
        DEF_CMD_ARG("genevegroup",              setgeneve_group_nl),
        DEF_CMD_ARG("genevelocalport",          setgeneve_local_port_nl),
        DEF_CMD_ARG("geneveremoteport",         setgeneve_remote_port_nl),
        DEF_CMD_ARG2("geneveportrange",         setgeneve_port_range_nl),
        DEF_CMD_ARG("genevetimeout",            setgeneve_timeout_nl),
        DEF_CMD_ARG("genevemaxaddr",            setgeneve_maxaddr_nl),
        DEF_CMD_ARG("genevedev",                setgeneve_dev_nl),
        DEF_CMD_ARG("genevettl",                setgeneve_ttl_nl),
        DEF_CMD_ARG("genevedf",                 setgeneve_df_nl),
        DEF_CMD("genevedscpinherit", 1,         setgeneve_inherit_dscp_nl),
        DEF_CMD("-genevedscpinherit", 0,        setgeneve_inherit_dscp_nl),
        DEF_CMD("genevelearn", 1,               setgeneve_learn_nl),
        DEF_CMD("-genevelearn", 0,              setgeneve_learn_nl),
        DEF_CMD("geneveflushall", 0,            setgeneve_flush_nl),
        DEF_CMD("geneveflush", 1,               setgeneve_flush_nl),
        DEF_CMD("geneveexternal", 1,            setgeneve_external_nl),
        DEF_CMD("-geneveexternal", 0,           setgeneve_external_nl),

        DEF_CMD_SARG("genevehwcsum",    IFCAP2_GENEVE_HWCSUM_NAME,
            setifcapnv),
        DEF_CMD_SARG("-genevehwcsum",   "-"IFCAP2_GENEVE_HWCSUM_NAME,
            setifcapnv),
        DEF_CMD_SARG("genevehwtso",     IFCAP2_GENEVE_HWTSO_NAME,
            setifcapnv),
        DEF_CMD_SARG("-genevehwtso",    "-"IFCAP2_GENEVE_HWTSO_NAME,
            setifcapnv),
};

static struct afswtch af_geneve = {
        .af_name                = "af_geneve",
        .af_af                  = AF_UNSPEC,
        .af_other_status        = geneve_status_nl,
};

static __constructor void
geneve_ctor(void)
{
        size_t i;

        for (i = 0; i < nitems(geneve_cmds); i++)
                cmd_register(&geneve_cmds[i]);
        af_register(&af_geneve);
        clone_setdefcallback_prefix("geneve", geneve_create_nl);
        SNL_VERIFY_PARSERS(all_parsers);
}