/*
 * iplink_xdp.c XDP program loader
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Authors:     Daniel Borkmann <daniel@iogearbox.net>
 */

#include <stdio.h>
#include <stdlib.h>

#include <linux/bpf.h>

#include "bpf_util.h"
#include "utils.h"
#include "ip_common.h"

extern int force;

struct xdp_req {
        struct iplink_req *req;
        __u32 flags;
};

static void xdp_ebpf_cb(void *raw, int fd, const char *annotation)
{
        struct xdp_req *xdp = raw;
        struct iplink_req *req = xdp->req;
        struct rtattr *xdp_attr;

        xdp_attr = addattr_nest(&req->n, sizeof(*req), IFLA_XDP);
        addattr32(&req->n, sizeof(*req), IFLA_XDP_FD, fd);
        if (xdp->flags)
                addattr32(&req->n, sizeof(*req), IFLA_XDP_FLAGS, xdp->flags);
        addattr_nest_end(&req->n, xdp_attr);
}

static const struct bpf_cfg_ops bpf_cb_ops = {
        .ebpf_cb = xdp_ebpf_cb,
};

static int xdp_delete(struct xdp_req *xdp)
{
        xdp_ebpf_cb(xdp, -1, NULL);
        return 0;
}

int xdp_parse(int *argc, char ***argv, struct iplink_req *req,
              const char *ifname, bool generic, bool drv, bool offload)
{
        struct bpf_cfg_in cfg = {
                .type = BPF_PROG_TYPE_XDP,
                .argc = *argc,
                .argv = *argv,
        };
        struct xdp_req xdp = {
                .req = req,
        };

        if (offload) {
                int ifindex = ll_name_to_index(ifname);

                if (!ifindex)
                        incomplete_command();
                cfg.ifindex = ifindex;
        }

        if (!force)
                xdp.flags |= XDP_FLAGS_UPDATE_IF_NOEXIST;
        if (generic)
                xdp.flags |= XDP_FLAGS_SKB_MODE;
        if (drv)
                xdp.flags |= XDP_FLAGS_DRV_MODE;
        if (offload)
                xdp.flags |= XDP_FLAGS_HW_MODE;

        if (*argc == 1) {
                if (strcmp(**argv, "none") == 0 ||
                    strcmp(**argv, "off") == 0)
                        return xdp_delete(&xdp);
        }

        if (bpf_parse_and_load_common(&cfg, &bpf_cb_ops, &xdp))
                return -1;

        *argc = cfg.argc;
        *argv = cfg.argv;
        return 0;
}

static void xdp_dump_json_one(struct rtattr *tb[IFLA_XDP_MAX + 1], __u32 attr,
                              __u8 mode)
{
        if (!tb[attr])
                return;

        open_json_object(NULL);
        print_uint(PRINT_JSON, "mode", NULL, mode);
        bpf_dump_prog_info(NULL, rta_getattr_u32(tb[attr]));
        close_json_object();
}

static void xdp_dump_json(struct rtattr *tb[IFLA_XDP_MAX + 1])
{
        __u32 prog_id = 0;
        __u8 mode;

        mode = rta_getattr_u8(tb[IFLA_XDP_ATTACHED]);
        if (tb[IFLA_XDP_PROG_ID])
                prog_id = rta_getattr_u32(tb[IFLA_XDP_PROG_ID]);

        open_json_object("xdp");
        print_uint(PRINT_JSON, "mode", NULL, mode);
        if (prog_id)
                bpf_dump_prog_info(NULL, prog_id);

        open_json_array(PRINT_JSON, "attached");
        if (tb[IFLA_XDP_SKB_PROG_ID] ||
            tb[IFLA_XDP_DRV_PROG_ID] ||
            tb[IFLA_XDP_HW_PROG_ID]) {
                xdp_dump_json_one(tb, IFLA_XDP_SKB_PROG_ID, XDP_ATTACHED_SKB);
                xdp_dump_json_one(tb, IFLA_XDP_DRV_PROG_ID, XDP_ATTACHED_DRV);
                xdp_dump_json_one(tb, IFLA_XDP_HW_PROG_ID, XDP_ATTACHED_HW);
        } else if (tb[IFLA_XDP_PROG_ID]) {
                /* Older kernel - use IFLA_XDP_PROG_ID */
                xdp_dump_json_one(tb, IFLA_XDP_PROG_ID, mode);
        }
        close_json_array(PRINT_JSON, NULL);

        close_json_object();
}

static void xdp_dump_prog_one(FILE *fp, struct rtattr *tb[IFLA_XDP_MAX + 1],
                              __u32 attr, bool link, bool details,
                              const char *pfx)
{
        __u32 prog_id;

        if (!tb[attr])
                return;

        prog_id = rta_getattr_u32(tb[attr]);
        if (!details) {
                if (prog_id && !link && attr == IFLA_XDP_PROG_ID)
                        fprintf(fp, "/id:%u", prog_id);
                return;
        }

        if (prog_id) {
                fprintf(fp, "%s    prog/xdp%s ", _SL_, pfx);
                bpf_dump_prog_info(fp, prog_id);
        }
}

void xdp_dump(FILE *fp, struct rtattr *xdp, bool link, bool details)
{
        struct rtattr *tb[IFLA_XDP_MAX + 1];
        __u8 mode;

        parse_rtattr_nested(tb, IFLA_XDP_MAX, xdp);

        if (!tb[IFLA_XDP_ATTACHED])
                return;

        mode = rta_getattr_u8(tb[IFLA_XDP_ATTACHED]);
        if (mode == XDP_ATTACHED_NONE)
                return;
        else if (is_json_context())
                return details ? (void)0 : xdp_dump_json(tb);
        else if (details && link)
                /* don't print mode */;
        else if (mode == XDP_ATTACHED_DRV)
                fprintf(fp, "xdp");
        else if (mode == XDP_ATTACHED_SKB)
                fprintf(fp, "xdpgeneric");
        else if (mode == XDP_ATTACHED_HW)
                fprintf(fp, "xdpoffload");
        else if (mode == XDP_ATTACHED_MULTI)
                fprintf(fp, "xdpmulti");
        else
                fprintf(fp, "xdp[%u]", mode);

        xdp_dump_prog_one(fp, tb, IFLA_XDP_PROG_ID, link, details, "");

        if (mode == XDP_ATTACHED_MULTI) {
                xdp_dump_prog_one(fp, tb, IFLA_XDP_SKB_PROG_ID, link, details,
                                  "generic");
                xdp_dump_prog_one(fp, tb, IFLA_XDP_DRV_PROG_ID, link, details,
                                  "drv");
                xdp_dump_prog_one(fp, tb, IFLA_XDP_HW_PROG_ID, link, details,
                                  "offload");
        }

        if (!details || !link)
                fprintf(fp, " ");
}