struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, uint32_t);
    __type(value, uint64_t);
    __uint(max_entries, 1024);
} icmp_count_map SEC(".maps");

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/icmp.h>
#include <arpa/inet.h>

// eBPF मानचित्र की परिभाषा
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, uint32_t);
    __type(value, uint64_t);
    __uint(max_entries, 1024);
} icmp_count_map SEC(".maps");

SEC("xdp")
int xdp_drop_icmp(struct xdp_md *ctx) {
    void *data_end = (void *)(unsigned long)ctx->data_end;
    void *data = (void *)(unsigned long)ctx->data;

    // इथरनेट हैडर के पॉइंटर को प्राप्त करें
    struct ethhdr *eth = data;
    if ((void *)eth + sizeof(*eth) > data_end)
        return XDP_PASS;

    // जांचें कि इथरनेट फ़्रेम में IP पैकेट शामिल है या नहीं
    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;

    // IP हैडर के पॉइंटर को प्राप्त करें
    struct iphdr *ip = data + sizeof(*eth);
    if ((void *)ip + sizeof(*ip) > data_end)
        return XDP_PASS;

    // जांचें कि प्रोटोकॉल ICMP है या नहीं
    if (ip->protocol != IPPROTO_ICMP)
        return XDP_PASS;

    // ICMP हैडर के पॉइंटर को प्राप्त करें
    struct icmphdr *icmp = (void *)ip + sizeof(*ip);
    if ((void *)icmp + sizeof(*icmp) > data_end)
        return XDP_PASS;

    // स्रोत IP पते को निकट करें
    uint32_t src_ip = ip->saddr;

    // स्रोत IP पते से icmp_count_map को खोजें
    uint64_t *count = bpf_map_lookup_elem(&icmp_count_map, &src_ip);

    // यदि u64 प्रकार का पॉइंटर NULL नहीं है, तो गणना में वृद्धि करें
    if (count) {
        __sync_fetch_and_add(count, 1);
    } else {
        // NULL होने पर, icmp_count_map में जोड़ें
        bpf_map_update_elem(&icmp_count_map, &src_ip, &(uint64_t){1}, BPF_ANY);
    }  

    // ICMP पैकेट को DROP करें
    return XDP_DROP;
}

char _license[] SEC("license") = "MIT";

$ clang -O2 -target bpf -g -c xdp.c -o xdp.o
$ sudo ip link set dev eth0 xdp obj xdp.o sec xdp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <linux/bpf.h>
#include <linux/if_link.h>
#include <bpf/libbpf.h>
#include <bpf/bpf.h>

int main(int argc, char **argv) {
    int map_fd = bpf_obj_get("/sys/fs/bpf/xdp/icmp_count_map");
    if (map_fd < 0) {
        perror("bpf_obj_get");
        return 1;
    }

    struct bpf_map_info map_info = {};
    uint32_t info_len = sizeof(map_info);
    if (bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len)) {
        perror("bpf_obj_get_info_by_fd");
        return 1;
    }

    // मानचित्र की जानकारी प्रदर्शित करें
    printf("मानचित्र का नाम: %s\n", map_info.name);
    printf("मानचित्र का प्रकार: %d\n", map_info.type);
    printf("मानचित्र की कुंजी का आकार: %d\n", map_info.key_size);
    printf("मानचित्र के मान का आकार: %d\n", map_info.value_size);
    printf("मानचित्र अधिकतम प्रविष्टियाँ: %d\n", map_info.max_entries);

    // सभी प्रविष्टियाँ प्राप्त करें
    uint32_t key, next_key;
    uint64_t value;
    key = next_key = 0;
    while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
        key = next_key; // अद्यतन की गई कुंजी का उपयोग करें
        if (bpf_map_lookup_elem(map_fd, &key, &value) == 0) {
            // IP पते को स्ट्रिंग में परिवर्तित करें
            char ip_str[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &key, ip_str, sizeof(ip_str));
            printf("कुंजी: %s, मान: %lu\n", ip_str, value);
        }
        key = next_key; // अगले लूप की तैयारी
    }

    return 0;
}

$ gcc -o map_info map_info.c -lbpf
$ sudo ./map_info
मानचित्र का नाम: icmp_count_map
मानचित्र का प्रकार: 1
मानचित्र की कुंजी का आकार: 4
मानचित्र के मान का आकार: 8
मानचित्र अधिकतम प्रविष्टियाँ: 1024
कुंजी: 192.168.XX.10, मान: 320
कुंजी: 192.168.XX.11, मान: 2307

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <linux/bpf.h>
#include <linux/if_link.h>
#include <bpf/libbpf.h>
#include <bpf/bpf.h>
#include <unistd.h>
#include <net/if.h>

int main(int argc, char **argv) {
    struct bpf_object *obj;
    struct bpf_map *map;
    struct bpf_program *prog;
    struct bpf_link *link = NULL;
    int map_fd, prog_fd;
    int err;

    if (argc != 2) {
        fprintf(stderr, "उपयोग: %s <इंटरफ़ेस>\n", argv[0]);
        return 1;
    }

    // xdp प्रोग्राम को लोड करें
    obj = bpf_object__open_file("./xdp.o", NULL);
    if (libbpf_get_error(obj)) {
        perror("BPF ऑब्जेक्ट को खोलने में विफल");
        return 1;
    }

    if (bpf_object__load(obj)) {
        perror("BPF ऑब्जेक्ट को लोड करने में विफल");
        return 1;
    }

    // प्रोग्राम को प्राप्त करें
    prog = bpf_object__find_program_by_name(obj, "xdp_drop_icmp");
    if (libbpf_get_error(prog)) {
        perror("नाम के द्वारा BPF प्रोग्राम को खोजने में विफल");
        return 1;
    }

    // मानचित्र को प्राप्त करें
    map = bpf_object__find_map_by_name(obj, "icmp_count_map");
    if (!map) {
        perror("नाम से BPF मानचित्र को खोजने में विफल");
        return 1;
    }

    map_fd = bpf_map__fd(map);
    if (map_fd < 0) {
        perror("मानचित्र fd प्राप्त करने में विफल");
        return 1;
    }

    // eth0 पर XDP प्रोग्राम को अटैच करें
    const char* if_name = argv[1];
    int ifindex = if_nametoindex(if_name);
    if (ifindex == 0) {
        perror("इंटरफ़ेस अनुक्रमांक प्राप्त करने में विफल");
        return 1;
    }

    link = bpf_program__attach_xdp(prog, ifindex);
    if (libbpf_get_error(link)) {
        perror("XDP प्रोग्राम को अटैच करने में विफल");
        return 1;
    }

    // अनंत लूप में 1 सेकंड में एक बार मानचित्र की स्थिति प्रदर्शित करें
    while (1) {
        // रेखा का विभाजन
        printf("==============================\n");
        // मानचित्र की जानकारी प्रदर्शित करें
        struct bpf_map_info map_info = {};
        uint32_t info_len = sizeof(map_info);
        if (bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len)) {
            perror("मानचित्र जानकारी प्राप्त करने में विफल");
            return 1;
        }

        printf("मानचित्र का नाम: %s\n", map_info.name);
        printf("मानचित्र का प्रकार: %d\n", map_info.type);
        printf("मानचित्र की कुंजी का आकार: %d\n", map_info.key_size);
        printf("मानचित्र के मान का आकार: %d\n", map_info.value_size);
        printf("मानचित्र अधिकतम प्रविष्टियाँ: %d\n", map_info.max_entries);

        // सभी प्रविष्टियाँ प्राप्त करें
        uint32_t key, next_key;
        uint64_t value;
        key = next_key = 0;
        while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
            key = next_key; // अद्यतन की गई कुंजी का उपयोग करें
            if (bpf_map_lookup_elem(map_fd, &key, &value) == 0) {
                // IP पते को स्ट्रिंग में परिवर्तित करें
                char ip_str[INET_ADDRSTRLEN];
                inet_ntop(AF_INET, &key, ip_str, sizeof(ip_str));
                printf("कुंजी: %s, मान: %lu\n", ip_str, value);
            }
            key = next_key; // अगले लूप की तैयारी
        }
        sleep(1);  // 1 सेकंड के अंतराल पर लूप
    }

    return 0;
}