#define __KERNEL__
#define MODULE

#include <linux/netfilter_ipv4.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/netfilter.h>


static struct nf_hook_ops nfho;

// 实际的hook函数，函数定义是固定的，
unsigned int hook_func(unsigned int hooknum,struct sk_buff *skb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff*)){
    // 返回NF_QUEUE，表示要将该数据包交给用户空间处理
    return NF_QUEUE;
}

// 模块初始化函数
int init(void){
    printk(KERN_INFO "init_module nf_kernel_custom_hook/n");
    // hook函数指向我们定义的hook函数
    nfho.hook = hook_func;
    /* hook点，表示我们要将我们的函数注册到NF_IP_PRE_ROUTING这个hook点 */
    nfho.hooknum = NF_IP_PRE_ROUTING;
    // 该hook点在IPv4数据包下生效
    nfho.pf = PF_INET;
    // 定义优先级
    nfho.priority = NF_IP_PRI_FIRST;
    nf_register_hook(&nfho);
    return 0;
}

// 模块卸载函数
void cleanup(void){
    printk(KERN_INFO "cleanup_module nf_kernel_custom_hook/n");
    nf_unregister_hook(&nfho);
}

// 声明模块的初始化/卸载函数分别是哪个
module_init(init);
module_exit(cleanup);

CONFIG_MODULE_SIG=n
obj-m+=nf_kernel_custom_hook.o
all:
	make  -C /lib/modules/$(shell uname -r)/build/ M=${PWD} modules
clean:
	make  -C /lib/modules/$(shell uname -r)/build/ M=${PWD} clean

static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
                          struct sock *sk, struct sk_buff *skb,
                          struct net_device *indev, struct net_device *outdev,
                          int (*okfn)(struct net *, struct sock *, struct sk_buff *))
{
        // 定义hook链表
        struct nf_hook_entries *hook_head = NULL;
        int ret = 1;

#ifdef CONFIG_JUMP_LABEL
        if (__builtin_constant_p(pf) &&
            __builtin_constant_p(hook) &&
            !static_key_false(&nf_hooks_needed[pf][hook]))
                return 1;
#endif
        rcu_read_lock();
        // 开始路由该数据包的hook链表（我们注册的hook就在这里边）
        // 可以看出，netfilter框架支持IPv4、IPv6、ARP（竟然还支持ARP，有点儿强大）、Bridge、DECnet；我们现在只需要IPv4，所以其他
        // 几个虽然有不认识的协议，但是我们并不关心，有兴趣的可以自行百度了解下其他几个协议，其实主要是DECnet这个没怎么见过；
        switch (pf) {
        case NFPROTO_IPV4:
                // 如果数据是IPv4的数据，那么会走这里，我们的hook函数也注册在hooks_ipv4里边，如果该hook点是NF_IP_PRE_ROUTING
                // 那么返回的hook链表里边将会包含我们上边的示例程序注册的函数；
                hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
                break;
        case NFPROTO_IPV6:
                hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
                break;
        case NFPROTO_ARP:
#ifdef CONFIG_NETFILTER_FAMILY_ARP
                if (WARN_ON_ONCE(hook >= ARRAY_SIZE(net->nf.hooks_arp)))
                        break;
                hook_head = rcu_dereference(net->nf.hooks_arp[hook]);
#endif
                break;
        case NFPROTO_BRIDGE:
#ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
                hook_head = rcu_dereference(net->nf.hooks_bridge[hook]);
#endif
                break;
#if IS_ENABLED(CONFIG_DECNET)
        case NFPROTO_DECNET:
                hook_head = rcu_dereference(net->nf.hooks_decnet[hook]);
                break;
#endif
        default:
                WARN_ON_ONCE(1);
                break;
        }

        // 如果对应的协议，对应的hook点有对应的hook函数，那么将调用nf_hook_slow
        if (hook_head) {
                struct nf_hook_state state;

                nf_hook_state_init(&state, hook, pf, indev, outdev,
                                   sk, net, okfn);

                ret = nf_hook_slow(skb, &state, hook_head, 0);
        }
        rcu_read_unlock();

        return ret;
}

int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state,
                 const struct nf_hook_entries *e, unsigned int s)
{
        unsigned int verdict;
        int ret;
        
        // 循环调用hook链表中的hook函数，可以看到NF_STOP操作确实已经废除了，所以这里只剩下四个操作了
        for (; s < e->num_hook_entries; s++) {
                verdict = nf_hook_entry_hookfn(&e->hooks[s], skb, state);
                switch (verdict & NF_VERDICT_MASK) {
                case NF_ACCEPT:
                        // 什么都不做，继续下个hook函数
                        break;
                case NF_DROP:
                        // 直接释放该网络数据包的内存（即删除）
                        kfree_skb(skb);
                        ret = NF_DROP_GETERR(verdict);
                        if (ret == 0)
                                ret = -EPERM;
                        return ret;
                case NF_QUEUE:
                        // 这里是我们需要的，可以看到对于返回NF_QUEUE的，最终都会调用nf_queue函数去处理，并且会将hook函数的决策结果
                        // verdict传入进去
                        ret = nf_queue(skb, state, s, verdict);
                        if (ret == 1)
                                continue;
                        return ret;
                default:
                        // 只要不是上边一个操作，都默认是NF_STOLEN
                        return 0;
                }
        }

        return 1;
}

int nf_queue(struct sk_buff *skb, struct nf_hook_state *state,
             unsigned int index, unsigned int verdict)
{
        int ret;
        
        ret = __nf_queue(skb, state, index, verdict >> NF_VERDICT_QBITS);
        if (ret < 0) {
                if (ret == -ESRCH &&
                    (verdict & NF_VERDICT_FLAG_QUEUE_BYPASS))
                        return 1;
                kfree_skb(skb);
        }

        return 0;
}

ret = __nf_queue(skb, state, index, verdict >> NF_VERDICT_QBITS);

return 1 << 16 | NF_QUEUE;