/* SPDX-License-Identifier: GPL-2.0-only */

#ifndef _TUNTAP_HELPERS_H
#define _TUNTAP_HELPERS_H

#include <errno.h>
#include <linux/if_packet.h>
#include <linux/ipv6.h>
#include <linux/virtio_net.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <netinet/udp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ynl.h>

#include "rt-route-user.h"
#include "rt-addr-user.h"
#include "rt-neigh-user.h"
#include "rt-link-user.h"

#define GENEVE_HLEN 8
#define PKT_DATA 0xCB
#define TUNTAP_DEFAULT_TTL 8
#define TUNTAP_DEFAULT_IPID 1337

unsigned int if_nametoindex(const char *ifname);

static inline int ip_addr_len(int family)
{
        return (family == AF_INET) ? sizeof(struct in_addr) :
                                     sizeof(struct in6_addr);
}

static inline void fill_ifaddr_msg(struct ifaddrmsg *ifam, int family,
                                   int prefix, int flags, const char *dev)
{
        ifam->ifa_family = family;
        ifam->ifa_prefixlen = prefix;
        ifam->ifa_index = if_nametoindex(dev);
        ifam->ifa_flags = flags;
        ifam->ifa_scope = RT_SCOPE_UNIVERSE;
}

static inline int ip_addr_add(const char *dev, int family, void *addr,
                              uint8_t prefix)
{
        int nl_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
        int ifa_flags = IFA_F_PERMANENT | IFA_F_NODAD;
        int ret = -1, ipalen = ip_addr_len(family);
        struct rt_addr_newaddr_req *req;
        struct ynl_sock *ys;

        ys = ynl_sock_create(&ynl_rt_addr_family, NULL);
        if (!ys)
                return -1;

        req = rt_addr_newaddr_req_alloc();
        if (!req)
                goto err_req_alloc;

        fill_ifaddr_msg(&req->_hdr, family, prefix, ifa_flags, dev);
        rt_addr_newaddr_req_set_nlflags(req, nl_flags);
        rt_addr_newaddr_req_set_local(req, addr, ipalen);

        ret = rt_addr_newaddr(ys, req);
        rt_addr_newaddr_req_free(req);
err_req_alloc:
        ynl_sock_destroy(ys);
        return ret;
}

static inline void fill_neigh_req_header(struct ndmsg *ndm, int family,
                                         int state, const char *dev)
{
        ndm->ndm_family = family;
        ndm->ndm_ifindex = if_nametoindex(dev);
        ndm->ndm_state = state;
        ndm->ndm_flags = 0;
        ndm->ndm_type = RTN_UNICAST;
}

static inline int ip_neigh_add(const char *dev, int family, void *addr,
                               unsigned char *lladdr)
{
        int nl_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
        int ret = -1, ipalen = ip_addr_len(family);
        struct rt_neigh_newneigh_req *req;
        struct ynl_sock *ys;

        ys = ynl_sock_create(&ynl_rt_neigh_family, NULL);
        if (!ys)
                return -1;

        req = rt_neigh_newneigh_req_alloc();
        if (!req)
                goto err_req_alloc;

        fill_neigh_req_header(&req->_hdr, family, NUD_PERMANENT, dev);
        rt_neigh_newneigh_req_set_nlflags(req, nl_flags);
        rt_neigh_newneigh_req_set_dst(req, addr, ipalen);
        rt_neigh_newneigh_req_set_lladdr(req, lladdr, ETH_ALEN);
        rt_neigh_newneigh_req_set_ifindex(req, if_nametoindex(dev));

        ret = rt_neigh_newneigh(ys, req);
        rt_neigh_newneigh_req_free(req);
err_req_alloc:
        ynl_sock_destroy(ys);
        return ret;
}

static inline void fill_route_req_header(struct rtmsg *rtm, int family,
                                         int table)
{
        rtm->rtm_family = family;
        rtm->rtm_table = table;
}

static inline int
ip_route_get(const char *dev, int family, int table, void *dst,
             void (*parse_rsp)(struct rt_route_getroute_rsp *rsp, void *out),
             void *out)
{
        int ret = -1, ipalen = ip_addr_len(family);
        struct rt_route_getroute_req *req;
        struct rt_route_getroute_rsp *rsp;
        struct ynl_sock *ys;

        ys = ynl_sock_create(&ynl_rt_route_family, NULL);
        if (!ys)
                return -1;

        req = rt_route_getroute_req_alloc();
        if (!req)
                goto err_req_alloc;

        fill_route_req_header(&req->_hdr, family, table);
        rt_route_getroute_req_set_nlflags(req, NLM_F_REQUEST);
        rt_route_getroute_req_set_dst(req, dst, ipalen);
        rt_route_getroute_req_set_oif(req, if_nametoindex(dev));

        rsp = rt_route_getroute(ys, req);
        if (!rsp)
                goto err_rsp_get;

        ret = 0;
        if (parse_rsp)
                parse_rsp(rsp, out);

        rt_route_getroute_rsp_free(rsp);
err_rsp_get:
        rt_route_getroute_req_free(req);
err_req_alloc:
        ynl_sock_destroy(ys);
        return ret;
}

static inline int
ip_link_add(const char *dev, char *link_type,
            int (*fill_link_attr)(struct rt_link_newlink_req *req, void *data),
            void *data)
{
        int nl_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
        struct rt_link_newlink_req *req;
        struct ynl_sock *ys;
        int ret = -1;

        ys = ynl_sock_create(&ynl_rt_link_family, NULL);
        if (!ys)
                return -1;

        req = rt_link_newlink_req_alloc();
        if (!req)
                goto err_req_alloc;

        req->_hdr.ifi_flags = IFF_UP;
        rt_link_newlink_req_set_nlflags(req, nl_flags);
        rt_link_newlink_req_set_ifname(req, dev);
        rt_link_newlink_req_set_linkinfo_kind(req, link_type);

        if (fill_link_attr && fill_link_attr(req, data) < 0)
                goto err_attr_fill;

        ret = rt_link_newlink(ys, req);
err_attr_fill:
        rt_link_newlink_req_free(req);
err_req_alloc:
        ynl_sock_destroy(ys);
        return ret;
}

static inline int ip_link_del(const char *dev)
{
        struct rt_link_dellink_req *req;
        struct ynl_sock *ys;
        int ret = -1;

        ys = ynl_sock_create(&ynl_rt_link_family, NULL);
        if (!ys)
                return -1;

        req = rt_link_dellink_req_alloc();
        if (!req)
                goto err_req_alloc;

        rt_link_dellink_req_set_nlflags(req, NLM_F_REQUEST);
        rt_link_dellink_req_set_ifname(req, dev);

        ret = rt_link_dellink(ys, req);
        rt_link_dellink_req_free(req);
err_req_alloc:
        ynl_sock_destroy(ys);
        return ret;
}

static inline size_t build_eth(uint8_t *buf, uint16_t proto, unsigned char *src,
                               unsigned char *dest)
{
        struct ethhdr *eth = (struct ethhdr *)buf;

        eth->h_proto = htons(proto);
        memcpy(eth->h_source, src, ETH_ALEN);
        memcpy(eth->h_dest, dest, ETH_ALEN);

        return ETH_HLEN;
}

static inline uint32_t add_csum(const uint8_t *buf, int len)
{
        uint16_t *sbuf = (uint16_t *)buf;
        uint32_t sum = 0;

        while (len > 1) {
                sum += *sbuf++;
                len -= 2;
        }

        if (len)
                sum += *(uint8_t *)sbuf;

        return sum;
}

static inline uint16_t finish_ip_csum(uint32_t sum)
{
        while (sum >> 16)
                sum = (sum & 0xffff) + (sum >> 16);
        return ~((uint16_t)sum);
}

static inline uint16_t build_ip_csum(const uint8_t *buf, int len, uint32_t sum)
{
        sum += add_csum(buf, len);
        return finish_ip_csum(sum);
}

static inline int build_ipv4_header(uint8_t *buf, uint8_t proto,
                                    int payload_len, struct in_addr *src,
                                    struct in_addr *dst)
{
        struct iphdr *iph = (struct iphdr *)buf;

        iph->ihl = 5;
        iph->version = 4;
        iph->ttl = TUNTAP_DEFAULT_TTL;
        iph->tot_len = htons(sizeof(*iph) + payload_len);
        iph->id = htons(TUNTAP_DEFAULT_IPID);
        iph->protocol = proto;
        iph->saddr = src->s_addr;
        iph->daddr = dst->s_addr;
        iph->check = build_ip_csum(buf, iph->ihl << 2, 0);

        return iph->ihl << 2;
}

static inline void ipv6_set_dsfield(struct ipv6hdr *ip6h, uint8_t dsfield)
{
        uint16_t val, *ptr = (uint16_t *)ip6h;

        val = ntohs(*ptr);
        val &= 0xF00F;
        val |= ((uint16_t)dsfield) << 4;
        *ptr = htons(val);
}

static inline int build_ipv6_header(uint8_t *buf, uint8_t proto,
                                    uint8_t dsfield, int payload_len,
                                    struct in6_addr *src, struct in6_addr *dst)
{
        struct ipv6hdr *ip6h = (struct ipv6hdr *)buf;

        ip6h->version = 6;
        ip6h->payload_len = htons(payload_len);
        ip6h->nexthdr = proto;
        ip6h->hop_limit = TUNTAP_DEFAULT_TTL;
        ipv6_set_dsfield(ip6h, dsfield);
        memcpy(&ip6h->saddr, src, sizeof(ip6h->saddr));
        memcpy(&ip6h->daddr, dst, sizeof(ip6h->daddr));

        return sizeof(struct ipv6hdr);
}

static inline int build_geneve_header(uint8_t *buf, uint32_t vni)
{
        uint16_t protocol = htons(ETH_P_TEB);
        uint32_t geneve_vni = htonl((vni << 8) & 0xffffff00);

        memcpy(buf + 2, &protocol, 2);
        memcpy(buf + 4, &geneve_vni, 4);
        return GENEVE_HLEN;
}

static inline int build_udp_header(uint8_t *buf, uint16_t sport, uint16_t dport,
                                   int payload_len)
{
        struct udphdr *udph = (struct udphdr *)buf;

        udph->source = htons(sport);
        udph->dest = htons(dport);
        udph->len = htons(sizeof(*udph) + payload_len);
        return sizeof(*udph);
}

static inline void build_udp_packet_csum(uint8_t *buf, int family,
                                         bool csum_off)
{
        struct udphdr *udph = (struct udphdr *)buf;
        size_t ipalen = ip_addr_len(family);
        uint32_t sum;

        /* No extension IPv4 and IPv6 headers addresses are the last fields */
        sum = add_csum(buf - 2 * ipalen, 2 * ipalen);
        sum += htons(IPPROTO_UDP) + udph->len;

        if (!csum_off)
                sum += add_csum(buf, udph->len);

        udph->check = finish_ip_csum(sum);
}

static inline int build_udp_packet(uint8_t *buf, uint16_t sport, uint16_t dport,
                                   int payload_len, int family, bool csum_off)
{
        struct udphdr *udph = (struct udphdr *)buf;

        build_udp_header(buf, sport, dport, payload_len);
        memset(buf + sizeof(*udph), PKT_DATA, payload_len);
        build_udp_packet_csum(buf, family, csum_off);

        return sizeof(*udph) + payload_len;
}

static inline int build_virtio_net_hdr_v1_hash_tunnel(uint8_t *buf, bool is_tap,
                                                      int hdr_len, int gso_size,
                                                      int outer_family,
                                                      int inner_family)
{
        struct virtio_net_hdr_v1_hash_tunnel *vh_tunnel = (void *)buf;
        struct virtio_net_hdr_v1 *vh = &vh_tunnel->hash_hdr.hdr;
        int outer_iphlen, inner_iphlen, eth_hlen, gso_type;

        eth_hlen = is_tap ? ETH_HLEN : 0;
        outer_iphlen = (outer_family == AF_INET) ? sizeof(struct iphdr) :
                                                   sizeof(struct ipv6hdr);
        inner_iphlen = (inner_family == AF_INET) ? sizeof(struct iphdr) :
                                                   sizeof(struct ipv6hdr);

        vh_tunnel->outer_th_offset = eth_hlen + outer_iphlen;
        vh_tunnel->inner_nh_offset = vh_tunnel->outer_th_offset + ETH_HLEN +
                                     GENEVE_HLEN + sizeof(struct udphdr);

        vh->csum_start = vh_tunnel->inner_nh_offset + inner_iphlen;
        vh->csum_offset = __builtin_offsetof(struct udphdr, check);
        vh->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
        vh->hdr_len = hdr_len;
        vh->gso_size = gso_size;

        if (gso_size) {
                gso_type = outer_family == AF_INET ?
                                   VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV4 :
                                   VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV6;
                vh->gso_type = VIRTIO_NET_HDR_GSO_UDP_L4 | gso_type;
        }

        return sizeof(struct virtio_net_hdr_v1_hash_tunnel);
}

#endif /* _TUNTAP_HELPERS_H */