// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
// Copyright (C) 2018 Facebook

#include <stdlib.h>
#include <string.h>
#include <bpf/libbpf.h>
#include <linux/rtnetlink.h>
#include <linux/tc_act/tc_bpf.h>

#include "bpf/nlattr.h"
#include "main.h"
#include "netlink_dumper.h"

static void xdp_dump_prog_id(struct nlattr **tb, int attr,
                             const char *mode,
                             bool new_json_object)
{
        if (!tb[attr])
                return;

        if (new_json_object)
                NET_START_OBJECT
        NET_DUMP_STR("mode", " %s", mode);
        NET_DUMP_UINT("id", " id %u", libbpf_nla_getattr_u32(tb[attr]))
        if (new_json_object)
                NET_END_OBJECT
}

static int do_xdp_dump_one(struct nlattr *attr, unsigned int ifindex,
                           const char *name)
{
        struct nlattr *tb[IFLA_XDP_MAX + 1];
        unsigned char mode;

        if (libbpf_nla_parse_nested(tb, IFLA_XDP_MAX, attr, NULL) < 0)
                return -1;

        if (!tb[IFLA_XDP_ATTACHED])
                return 0;

        mode = libbpf_nla_getattr_u8(tb[IFLA_XDP_ATTACHED]);
        if (mode == XDP_ATTACHED_NONE)
                return 0;

        NET_START_OBJECT;
        if (name)
                NET_DUMP_STR("devname", "%s", name);
        NET_DUMP_UINT("ifindex", "(%u)", ifindex);

        if (mode == XDP_ATTACHED_MULTI) {
                if (json_output) {
                        jsonw_name(json_wtr, "multi_attachments");
                        jsonw_start_array(json_wtr);
                }
                xdp_dump_prog_id(tb, IFLA_XDP_SKB_PROG_ID, "generic", true);
                xdp_dump_prog_id(tb, IFLA_XDP_DRV_PROG_ID, "driver", true);
                xdp_dump_prog_id(tb, IFLA_XDP_HW_PROG_ID, "offload", true);
                if (json_output)
                        jsonw_end_array(json_wtr);
        } else if (mode == XDP_ATTACHED_DRV) {
                xdp_dump_prog_id(tb, IFLA_XDP_PROG_ID, "driver", false);
        } else if (mode == XDP_ATTACHED_SKB) {
                xdp_dump_prog_id(tb, IFLA_XDP_PROG_ID, "generic", false);
        } else if (mode == XDP_ATTACHED_HW) {
                xdp_dump_prog_id(tb, IFLA_XDP_PROG_ID, "offload", false);
        }

        NET_END_OBJECT_FINAL;
        return 0;
}

int do_xdp_dump(struct ifinfomsg *ifinfo, struct nlattr **tb)
{
        if (!tb[IFLA_XDP])
                return 0;

        return do_xdp_dump_one(tb[IFLA_XDP], (unsigned int)ifinfo->ifi_index,
                               libbpf_nla_getattr_str(tb[IFLA_IFNAME]));
}

static int do_bpf_dump_one_act(struct nlattr *attr)
{
        struct nlattr *tb[TCA_ACT_BPF_MAX + 1];

        if (libbpf_nla_parse_nested(tb, TCA_ACT_BPF_MAX, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;

        if (!tb[TCA_ACT_BPF_PARMS])
                return -LIBBPF_ERRNO__NLPARSE;

        NET_START_OBJECT_NESTED2;
        if (tb[TCA_ACT_BPF_NAME])
                NET_DUMP_STR("name", "%s",
                             libbpf_nla_getattr_str(tb[TCA_ACT_BPF_NAME]));
        if (tb[TCA_ACT_BPF_ID])
                NET_DUMP_UINT("id", " id %u",
                              libbpf_nla_getattr_u32(tb[TCA_ACT_BPF_ID]));
        NET_END_OBJECT_NESTED;
        return 0;
}

static int do_dump_one_act(struct nlattr *attr)
{
        struct nlattr *tb[TCA_ACT_MAX + 1];

        if (!attr)
                return 0;

        if (libbpf_nla_parse_nested(tb, TCA_ACT_MAX, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;

        if (tb[TCA_ACT_KIND] &&
            strcmp(libbpf_nla_data(tb[TCA_ACT_KIND]), "bpf") == 0)
                return do_bpf_dump_one_act(tb[TCA_ACT_OPTIONS]);

        return 0;
}

static int do_bpf_act_dump(struct nlattr *attr)
{
        struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
        int act, ret;

        if (libbpf_nla_parse_nested(tb, TCA_ACT_MAX_PRIO, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;

        NET_START_ARRAY("act", " %s [");
        for (act = 0; act <= TCA_ACT_MAX_PRIO; act++) {
                ret = do_dump_one_act(tb[act]);
                if (ret)
                        break;
        }
        NET_END_ARRAY("] ");

        return ret;
}

static int do_bpf_filter_dump(struct nlattr *attr)
{
        struct nlattr *tb[TCA_BPF_MAX + 1];
        int ret;

        if (libbpf_nla_parse_nested(tb, TCA_BPF_MAX, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;

        if (tb[TCA_BPF_NAME])
                NET_DUMP_STR("name", " %s",
                             libbpf_nla_getattr_str(tb[TCA_BPF_NAME]));
        if (tb[TCA_BPF_ID])
                NET_DUMP_UINT("id", " id %u",
                              libbpf_nla_getattr_u32(tb[TCA_BPF_ID]));
        if (tb[TCA_BPF_ACT]) {
                ret = do_bpf_act_dump(tb[TCA_BPF_ACT]);
                if (ret)
                        return ret;
        }

        return 0;
}

int do_filter_dump(struct tcmsg *info, struct nlattr **tb, const char *kind,
                   const char *devname, int ifindex)
{
        int ret = 0;

        if (tb[TCA_OPTIONS] &&
            strcmp(libbpf_nla_data(tb[TCA_KIND]), "bpf") == 0) {
                NET_START_OBJECT;
                if (devname[0] != '\0')
                        NET_DUMP_STR("devname", "%s", devname);
                NET_DUMP_UINT("ifindex", "(%u)", (unsigned int)ifindex);
                NET_DUMP_STR("kind", " %s", kind);
                ret = do_bpf_filter_dump(tb[TCA_OPTIONS]);
                NET_END_OBJECT_FINAL;
        }

        return ret;
}