这个实验其实就是之前网络编程一个实验，不过因为代码是拿老师的代码进行修改的，所以就没有写对应的博客。
实验要求基于操作系统内核驱动，设计实现一个简单防火墙系统
实验思路可以基于netfilter框架，编写内核防火墙模块（驱动）和用户态防火墙控制程序，实现服务协议、IP地址、端口等的控制和过滤。
实验环境使用的虚拟机：VMware16中的Ubuntu2020
使用的操作系统：Linux操作系统
使用的语言：C语言[gcc (Ubuntu 11.1.0-1uUbuntu1-20.04) 11.1.0]
使用的内核版本：Linux ubuntu2020 5.15.0-69-generic
实验中遇到的问题第一个问题是内核版本的问题，在将使用make进行编译内核代码的时候，报错显示nfhoSockopt.set = hookSockoptSet; 这里赋值的变量类型不匹配，但是我百度查书都显示这是可以赋值的，所以估计是内核版本的问题。再看报错有提示说将一些警告视为报错了，经百度发现可以通过在makefile文件中添加KBUILD_CFLAGS += -w 可以解决这个问题。当然，也可以将对应函数的代码版本改成当前的代码版本。
第二个问题是，在删除规则的时候，规则不存在，但是防火墙没有进行提示且显示setsockopt()success，用户层的代码确实和内核层完成了信息交互，但是如果提前进行判断，就可以不用与内核进行信息交互了。这个问题可以通过在用户层将数据交给内核层的时候，先获取内核层中的规则集，然后比较要删除的规则是否在规则集中，如果在那么可以进行删除，否则输出提示要删除的规则不存在。
第三个问题是，在添加了一个规则后，再次添加完全相同的规则时，仍能添加成功，显然代码在添加规则时没有进行查重判断。这一个问题可以和上一个问题一起解决，在添加规则之前先获取内核层的规则集，然后进行遍历，看是否有完全一样的规则。当然，解决这个问题还需要获取当前输入的规则的信息，所以我创建了一个全局变量来保存输入时候的规则，所以可以进行比较。如果遍历规则集时发现有一样的规则，那么不进行添加并且输出该规则已存在的信息。
第四个问题是规则优先级的问题（规则匹配的问题），在输入新规则进行查重之后，如果有两个规则除了最后一个参数其他都一样，也就是一个是allow另一个是reject，那么是允许还是拒绝？正常来说，后面输入的优先级高，所以如果添加规则的时候是类似与头插法，那么只需要找到第一个符合的规则就退出规则匹配，如果是尾插法，也就是将新规则放在最后，那么要匹配到最后一个符合的规则才行。从节省时间的角度出发，当然是将新规则放在首位更加节省时间，所以匹配到第一个符合的规则即可退出匹配。
2024年6月20日晚添加：使用到的测试命令发现很多同学看了不知道怎么运行，我这里来说明一下。
最好虚拟机的版本和内核是和我差不多的，不然很有可能会有未知的错误（函数过期啊啥的，当然不一样的能运行也可以）
首先将我下面的三个代码复制到同一个目录下面（这个目录最好只有这个三个文件），然后右键在这个目录下打开终端。下面就是具体的命令了。
第一条命令是：make。（make正常的话会生成一个myfw.ko文件，这个就是生成的内核的模块了。如果报错的话原因就有很多种了，建议是先自行百度看能解决吗，也可以问题但我不一定能给出好的解决方案。实在不行可以放弃看我这篇博客了。。。。）。强调一下，myfw.c这个代码是内核层的代码，不能在用户层编译，并且这个代码在make 的时候会自动编译。
第二条命令就是编译myfwctl.c文件：
gcc -o myfwctl myfwctl.c
第三条命令就是加载myfw.ko模块：
sudo insmod myfw.ko
提一嘴，移除模块的命令是：sudo rmmod myfw.ko
其他命令说明一下，sudo ./myfwctl rule 就是查看现有的规则。sudo ./myfwctl rule del n就是删除第n条规则(前提是规则存在)。sudo ./myfwctl rule add any any any any ICMP a/r，这条命令就是拿来添加规则的。这四个any按顺序分别代表：发送端端口 发送端ip 接收端端口 接收端ip，ICMP就是使用的协议了，可以改为其他协议但我没测试过(就用过ping来测试)。最后还有一个字母a或者r，分别是allow和reject的缩写，分别代表允许和拒绝。大概就这些了，有问题可以评论或者私信我，我看到会及时回复的。
还有就是查看日志的命令，sudo su输入ubuntu的密码进入管理员权限然后使用dmesg就可以查看日志了。
测试效果运行防火墙后，删除不存在规则：
可以看到，规则不存在会进行提示
连续添加两个相同的规则：
通过ifconfig命令获取虚拟机的ip地址后用主机ping
可以看到，此时防火墙允许主机ping
查看主机ip并添加规则禁止主机ping虚拟机：
我的主机ip为：192.168.110.1
说明防火墙成功的将主机发送的数据包丢弃。
最后查看输出的日志：
该防火墙代码主要有3部分，头文件代码(myfw.c)、内核层代码(myfw.c)和用户层代码(myfwctl.c)，另外还有一个Makefile工程文件，用于将这3个代码编译并生成内核模块，之后加载该模块，就可以运行用户层代码，进行防火墙的测试了。
内核层代码（myfw.c）：
#include <linux/module.h> #include <linux/kernel.h> #include <linux/skbuff.h>//包含sk_buff结构 #include <net/tcp.h> #include <linux/netdevice.h> #include <linux/netfilter.h> #include <linux/netfilter_ipv4.h> #include "myfw.h" //内核层的代码 //使用静态变量更适合与模块化编程，使用static进行定义的结构或变量只能在本文件中使用 //定义detfilter的5个钩子点： static struct nf_hook_ops nfhoLocalIn; static struct nf_hook_ops nfhoLocalOut; static struct nf_hook_ops nfhoPreRouting; static struct nf_hook_ops nfhoForward; static struct nf_hook_ops nfhoPostRouting; //创建套接字选项，与用户层通信 static struct nf_sockopt_ops nfhoSockopt; static int debug_level = 0; static int nfcount = 0; static Rule* g_rules;//规则集,用指针形式来记录可以更省空间 static int g_rules_count = 0;//用来记录规则的个数 //------函数声明------ void addRule(Rule* rule);//增加规则的函数 void delRule(int rule_num);//删除规则，输入的参数表示要删除的规则的编号 int matchRule(void* skb);//进行规则比较的函数，判断是否能进行通信 void debugInfo(char* msg);//记录操作次数，将每次的操作信息输出到日志 //sk_buff就是传入的数据包，*skb unsigned int hookLocalIn(void* priv, struct sk_buff* skb, const struct nf_hook_state* state); unsigned int hookLocalOut(void* priv, struct sk_buff* skb, const struct nf_hook_state* state); unsigned int hookPreRouting(void* priv, struct sk_buff* skb, const struct nf_hook_state* state); unsigned int hookPostRouting(void* priv, struct sk_buff* skb, const struct nf_hook_state* state); unsigned int hookForward(void* priv, struct sk_buff* skb, const struct nf_hook_state* state); //用于接收用户端数据的函数 int hookSockoptSet(struct sock* sock, int cmd, void __user* user, unsigned int len); //用与将数据传到用户层的函数 int hookSockoptGet(struct sock* sock, int cmd, void __user* user, int* len); int init_module();//内核模块初始化,初始化五个钩子（进行钩子的注册） void cleanup_module();//将钩子注销 //------函数实现------ void addRule(Rule* rule)//增加规则的函数 { //这一个函数是先将要添加的规则放入新的规则集中，再把原来的规则集放到新的规则集中 //所以每次添加规则时，添加的规则都会放到第一位 int r_c = g_rules_count + 1;//将规则个数+1 Rule* g_r = (Rule*)vmalloc(r_c * sizeof(Rule));//开辟相应大小的空间 memcpy(g_r, rule, sizeof(Rule));//将要增加的规则放到新开辟的规则集中 if (g_rules_count > 0){//如果原规则集中有规则，则先将原来的规则集赋值给新规则集 memcpy(g_r + 1, g_rules, g_rules_count * sizeof(Rule)); vfree(g_rules);//回收之前的rule，释放空间 } g_rules = g_r;//将新的规则集赋值给全局规则集 g_rules_count = r_c;//更新规则集中规则的数量 } void delRule(int rule_num)//删除规则，输入的参数表示要删除的规则的编号 { int i; if (rule_num > 0 && rule_num <= g_rules_count){//如果输入的规则编号有效，则进行删除 for (i = rule_num; i < g_rules_count; i++){ //把要删除的规则的位置之后的规则都往前移一个位置，将要删除的规则覆盖掉 memcpy(g_rules + i - 1, g_rules + i, sizeof(Rule)); } g_rules_count--;//最后一个空间闲着，不用管 } } int matchRule(void* skb)//进行规则比较的函数，判断是否能进行通信 { //增加了端口控制的规则匹配 int sport = 0; int dport = 0; struct iphdr* iph = ip_hdr(skb); struct tcphdr* tcph; struct udphdr* udph; int act = 1, i; Rule* r; for (i = 0; i < g_rules_count; i++){//遍历规则集 r = g_rules + i;//用r来遍历 if ((!r->sip || r->sip == iph->saddr) && (!r->dip || r->dip == iph->daddr) && (!r->protocol || r->protocol == iph->protocol)){ switch (iph->protocol){//对协议类型进行判断进行判断 case MYFW_TCP: tcph = (struct tcphdr*)skb_transport_header(skb); sport = tcph->source; dport = tcph->dest; break; case MYFW_UDP: udph = (struct udphdr*)skb_transport_header(skb); sport = udph->source; dport = udph->dest; break; } if ((!r->sport || !sport || r->sport == sport) && (!r->dport || !dport || r->dport == dport)){ act = r->allow; } } } return act; } void debugInfo(char* msg)//记录操作次数，将每次的操作信息输出到日志 { if (debug_level){//如果等级符合要求，才进行+1和输出到日志 nfcount++; printk("%s, nfcount: %d\n", msg, nfcount); } } unsigned int hookLocalIn(void* priv, struct sk_buff* skb,//sk_buff就是传入的数据包，*skb const struct nf_hook_state* state) { unsigned rc = NF_ACCEPT;//默认继续传递，保持和原来输出的一致 if (matchRule(skb) <= 0)//查规则集，如果返回值<=0，那么不允许进行通信 rc = NF_DROP;//丢弃包，不再继续传递 debugInfo("hookLocalIn"); return rc;//返回是是否允许通信，是否丢包 } unsigned int hookLocalOut(void* priv, struct sk_buff* skb, const struct nf_hook_state* state) { debugInfo("hookLocalOut"); return NF_ACCEPT;//接收该数据 } unsigned int hookPreRouting(void* priv, struct sk_buff* skb, const struct nf_hook_state* state) { debugInfo("hookPreRouting"); return NF_ACCEPT;//接收该数据 } unsigned int hookPostRouting(void* priv, struct sk_buff* skb, const struct nf_hook_state* state) { debugInfo("hookPostRouting"); return NF_ACCEPT;//接收该数据 } unsigned int hookForward(void* priv, struct sk_buff* skb, const struct nf_hook_state* state) { debugInfo("hookForwarding"); return NF_ACCEPT;//接收该数据 } int hookSockoptSet(struct sock* sock, int cmd, void __user* user, unsigned int len)//用于接收用户端数据的函数 { int ret = 0; Rule r; int r_num; debugInfo("hookSockoptSet"); switch (cmd){ case CMD_DEBUG: //copy_from_user函数的作用：用于将用户空间的数据拷贝到内核空间 ret = copy_from_user(&debug_level, user, sizeof(debug_level)); printk("set debug level to %d", debug_level);//设置debug等级 break; case CMD_RULE: ret = copy_from_user(&r, user, sizeof(Rule));//如果是添加规则 addRule(&r); printk("add rule");//输出到日志 break; case CMD_RULE_DEL: ret = copy_from_user(&r_num, user, sizeof(r_num));//删除规则 delRule(r_num); printk("del rule");//输出到日志 break; } if (ret != 0)//说明赋值失败，进行输出 { printk("copy_from_user error"); ret = -EINVAL; } return ret; } int hookSockoptGet(struct sock* sock, int cmd, void __user* user, int* len)//用与将数据传到用户层的函数 { int ret; debugInfo("hookSockoptGet"); switch (cmd){ case CMD_DEBUG: ret = copy_to_user(user, &debug_level, sizeof(debug_level)); break; case CMD_RULE: //copy_to_user函数的作用：将内核空间的数据拷贝到用户空间 //拷贝成功返回0 ret = copy_to_user(user, &g_rules_count, sizeof(g_rules_count)); ret = copy_to_user(user + sizeof(g_rules_count), g_rules, sizeof(Rule) * g_rules_count); break; } if (ret != 0){ ret = -EINVAL; debugInfo("copy_to_user error"); } return ret; } int init_module()//内核模块初始化,初始化五个钩子（进行钩子的注册） { nfhoLocalIn.hook = hookLocalIn;//设置一些参数 nfhoLocalIn.hooknum = NF_INET_LOCAL_IN;//注册回调函数 nfhoLocalIn.pf = PF_INET; nfhoLocalIn.priority = NF_IP_PRI_FIRST; nf_register_net_hook(&init_net, &nfhoLocalIn);//注册hook nfhoLocalOut.hook = hookLocalOut; nfhoLocalOut.hooknum = NF_INET_LOCAL_OUT; nfhoLocalOut.pf = PF_INET; nfhoLocalOut.priority = NF_IP_PRI_FIRST; nf_register_net_hook(&init_net, &nfhoLocalOut); nfhoPreRouting.hook = hookPreRouting; nfhoPreRouting.hooknum = NF_INET_PRE_ROUTING; nfhoPreRouting.pf = PF_INET; nfhoPreRouting.priority = NF_IP_PRI_FIRST; nf_register_net_hook(&init_net, &nfhoPreRouting); nfhoForward.hook = hookForward; nfhoForward.hooknum = NF_INET_FORWARD; nfhoForward.pf = PF_INET; nfhoForward.priority = NF_IP_PRI_FIRST; nf_register_net_hook(&init_net, &nfhoForward); nfhoPostRouting.hook = hookPostRouting; nfhoPostRouting.hooknum = NF_INET_POST_ROUTING; nfhoPostRouting.pf = PF_INET; nfhoPostRouting.priority = NF_IP_PRI_FIRST; nf_register_net_hook(&init_net, &nfhoPostRouting); nfhoSockopt.pf = PF_INET;//PF_INET表示协议族 nfhoSockopt.set_optmin = CMD_MIN; nfhoSockopt.set_optmax = CMD_MAX; nfhoSockopt.set = hookSockoptSet; nfhoSockopt.get_optmin = CMD_MIN; nfhoSockopt.get_optmax = CMD_MAX; nfhoSockopt.get = hookSockoptGet; nf_register_sockopt(&nfhoSockopt);//注册扩展套接字选项 printk("myfirewall started\n");//将信息输出到日志中 return 0; } void cleanup_module()//将钩子注销 { nf_unregister_net_hook(&init_net, &nfhoLocalIn);//将5个hook注销 nf_unregister_net_hook(&init_net, &nfhoLocalOut); nf_unregister_net_hook(&init_net, &nfhoPreRouting); nf_unregister_net_hook(&init_net, &nfhoForward); nf_unregister_net_hook(&init_net, &nfhoPostRouting); nf_unregister_sockopt(&nfhoSockopt); printk("myfirewall stopped\n");//输出相应的信息 } MODULE_LICENSE("GPL");//模块的许可证声明，防止收到内核被污染的警告用户层代码（myfwctl.c）：
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <unistd.h> #include <pthread.h> #include <signal.h> #include <errno.h> #include "myfw.h" //这一个是用户层代码 //------全局变量------ //创建一个全局变量，将要添加规则时的信息进行保留 Rule *pd_temp; //------函数声明------ void printError(char* msg);//输出错误信息的函数 void printSuccess(char* msg);//输出成功信息的函数 void usage(char* program);//输出一些信息 unsigned int str2Ip(char* ipstr);//字符串类型的ip转换为整型 char* ip2Str(unsigned int ip, char buf[32]);//将整型的ip转为字符型的ip unsigned short str2Port(char* portstr);//将端口转为整型 char* port2Str(unsigned short port, char buf[16]);//将整型端口构造为字符 char* protocol2Str(unsigned short protocol, char buf[16]);//将整型协议进行转为字符串 unsigned short str2Protocol(char* protstr);//将字符串类型的协议转为短整型的协议 void printRuleTable(RuleTable* rtb);//将规则集中的规则输出 int set(int cmd, void* val, int val_len, int sockfd);//将信息传到内核对规则进行修改 int get(int cmd, int sockfd);//将规则集进行输出或输出debug_level int parseArgs(int argc, char* argv[], int* cmd, void* val, int* val_len);//获取用户端输入的信息并进行处理 //------主函数------ int main(int argc, char *argv[]) { int ret = -1; int cmd; char val[sizeof(Rule)]; int val_len; int get_set = parseArgs(argc, argv, &cmd, val, &val_len);//将输入的参数进行处理 if (get_set)//如果函数返回值不为零 { int sockfd; //创建套接字，SOCK_RAW是RAW类型，提供原始网络协议访问 //AF_INET设置地址族，IPPRPTP_RAW：原始IP数据包 if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1) printError("socket()");//创建套接字失败输出错误信息 else { if (get_set > 0) ret = set(cmd, val, val_len, sockfd); //将信息传到内核层，对规则集进行修改 else ret = get(cmd, sockfd); close(sockfd);//关闭套接字 } } else usage(argv[0]);//到这里说明是输入不对，对输入的格式进行提示 return ret;//结束用户端程序 } //------函数实现------ void printError(char* msg)//输出错误信息的函数 { printf("%s error %d: %s\n", msg, errno, strerror(errno)); } void printSuccess(char* msg)//输出成功信息的函数 { printf("%s success\n", msg); } void usage(char* program)//输出一些输入格式信息 { printf("please check your input，the correct input format is:\n"); printf("%s debug\n", program); printf("%s debug debug_level\n", program); printf("%s rule add sip sport dip dport protocol a|r\n", program); printf("%s rule del rule_number\n", program); printf("%s rule\n", program); } unsigned int str2Ip(char* ipstr)//字符串类型的ip转换为整型 { unsigned int ip; if (!strcmp(ipstr, "any"))ip = 0;//如果是any，表示任何任何端口或ip都可以，用0表示 else inet_pton(AF_INET, ipstr, &ip);//将ip地址转换为用于网络传输的数值格式 return ip; } char* ip2Str(unsigned int ip, char buf[32])//将整型的ip转为字符型的ip { if (ip){ unsigned char* c = (unsigned char*)&ip; sprintf(buf, "%d.%d.%d.%d", *c, *(c + 1), *(c + 2), *(c + 3)); } else sprintf(buf, "any"); return buf; } unsigned short str2Port(char* portstr)//将端口转为整型 { unsigned short port; if (!strcmp(portstr, "any"))port = 0; else port = atoi(portstr); return port; } char* port2Str(unsigned short port, char buf[16])//将整型端口构造为字符 { if (port)sprintf(buf, "%d", port); else sprintf(buf, "any"); return buf; } char* protocol2Str(unsigned short protocol, char buf[16])//将整型协议进行转为字符串 { switch (protocol){ case 0: strcpy(buf, "any"); break; case MYFW_ICMP: strcpy(buf, "ICMP"); break; case MYFW_TCP: strcpy(buf, "TCP"); break; case MYFW_UDP: strcpy(buf, "UDP"); break; default: strcpy(buf, "Unknown"); } return buf; } unsigned short str2Protocol(char* protstr)//将字符串类型的协议转为短整型的协议 { unsigned short protocol = 0; if (!strcmp(protstr, "any")) protocol = 0;//0表示任何端口 else if (!strcmp(protstr, "ICMP"))protocol = MYFW_ICMP; else if (!strcmp(protstr, "TCP"))protocol = MYFW_TCP; else if (!strcmp(protstr, "UDP"))protocol = MYFW_UDP; return protocol; } void printRuleTable(RuleTable* rtb)//将规则集中的规则输出 { char sip[32], dip[32], sport[16], dport[16], protocol[16]; Rule* r = &(rtb->rule); printf("Rules count: %d\n", rtb->count); for (int i = 0; i < rtb->count; i++){//遍历规则集 ip2Str(r->sip, sip);//将源ip进行转换 ip2Str(r->dip, dip);//将目的地址进行转换 port2Str(r->sport, sport);//将源端口进行转换 port2Str(r->dport, dport);//将目的端口进行转换 protocol2Str(r->protocol, protocol);//将协议进行转换 //进行输出 printf("%d\t%s:%s -> %s:%s, %s is %s\n", i + 1, sip, sport, dip, dport, protocol, r->allow ? "allow" : "reject"); r = r + 1;//移到下一个规则 } } int set(int cmd, void* val, int val_len, int sockfd)//将信息传到内核对规则进行修改 { //val_len表示的是数据类型的长度，不是规则集的个数 int ret = -1; //判断要添加的规则或要删除的规则是否在规则集中 int new_val_len = 1024 * 1024; void* new_val = malloc(new_val_len); //从内核层获取规则表 if (getsockopt(sockfd, IPPROTO_IP, CMD_RULE, new_val, &new_val_len)) printError("getsockopt");//输出错误信息，说明从内核层获取信息失败 else { RuleTable* rules = (RuleTable*)new_val; Rule* r = &(rules->rule); if (cmd == CMD_RULE_DEL) {//要进行删除操作 RuleTable* rules2 = (RuleTable*)val; if (rules2->count > rules->count) {//说明规则集中不存在该规则 printf("failed to delete：the rule to delete does not exist\n"); return 0;//不存在不需要删除 } } else if (cmd == CMD_RULE) { for (int i = 0; i < rules->count; i++) {//遍历规则集,判断是否已经存在要添加的规则。 if (pd_temp->allow == r->allow && pd_temp->dip == r->dip && pd_temp->dport == r->dport && pd_temp->protocol == r->protocol && pd_temp->sip == r->sip && pd_temp->sport == r->sport) { printf("failed to add：rule to add already exists\n"); return 0;//已存在不需要添加 } r = r + 1;//移到下一个规则 } } } //若无错误发生，setsockopt返回0，否则返回socket_error错误 if (setsockopt(sockfd, IPPROTO_IP, cmd, val, val_len)) printError("setsockopt()");//输出错误信息，说明消息传到内核失败或创建套接字失败 else{ printf("setsockopt() success\n");//前后的长度不相同说明添加或删除成功 //获取当前的规则集并进行输出 //从内核层获取规则表 int new_val_len1 = 1024 * 1024; void* new_val1 = malloc(new_val_len1); if (getsockopt(sockfd, IPPROTO_IP, CMD_RULE, new_val1, &new_val_len1)) printError("getsockopt");//输出错误信息，说明从内核层获取信息失败 else { printf("Current rule set:\n"); printRuleTable(new_val1);//将规则集进行输出 } ret = 0; } return ret; } int get(int cmd, int sockfd)//将规则集进行输出或输出debug_level { int ret = -1; int val_len = 1024 * 1024; void* val = malloc(val_len); if (getsockopt(sockfd, IPPROTO_IP, cmd, val, &val_len))printError("getsockopt");//输出错误信息 else{ switch (cmd){ case CMD_DEBUG://如果输入的是debug，那么输出debug等级 printf("debug level=%d\n", *(int*)val); break; case CMD_RULE://输入的是rule，则将规则集中的数据进行输出 printRuleTable((RuleTable*)val); break; } } return ret; } int parseArgs(int argc, char* argv[], int* cmd, void* val, int* val_len)//获取用户端输入的信息并进行处理 { int ret = 0;//初始将ret设为0 //argc是输入的参数个数 //argv数组是存放输入的参数 if (argc == 2){//说明不需要添加或者删除规则 if (!strcmp(argv[1], "debug")){ *cmd = CMD_DEBUG; ret = -1; } else if (!strcmp(argv[1], "rule")){ *cmd = CMD_RULE; ret = -1; } } else if (argc > 2){ if (!strcmp(argv[1], "debug") && argc == 3){ *cmd = CMD_DEBUG; *(int*)val = atoi(argv[2]); *val_len = sizeof(int); ret = 1; } else if (!strcmp(argv[1], "rule")){//说明要对规则进行操作 if (argc == 4){ if (!strcmp(argv[2], "del")){//删除规则 *cmd = CMD_RULE_DEL; *(int*)val = atoi(argv[3]); *val_len = sizeof(int); ret = 1; } } else if (argc == 9){ if (!strcmp(argv[2], "add")){//添加规则 *cmd = CMD_RULE; Rule* r = (Rule*)val; *val_len = sizeof(Rule); r->sip = str2Ip(argv[3]);//下面都是对输入的参数进行处理，将字符串转为数字或其他类型 r->sport = str2Port(argv[4]); r->dip = str2Ip(argv[5]); r->dport = str2Port(argv[6]); r->protocol = str2Protocol(argv[7]); r->allow = strcmp(argv[8], "a") ? 0 : 1;//如果是a，说明是允许通信，赋值为1，否则赋值为0 pd_temp = r;//将变量保存，用于后面添加规则时进行判断 ret = 1; } } } } return ret; }头文件代码（myfw.h）：
#define CMD_MIN 0x6000//十进制：24576 #define CMD_DEBUG CMD_MIN+1 #define CMD_RULE CMD_MIN+2 #define CMD_RULE_DEL CMD_MIN+3 #define CMD_MAX 0x6100//十进制：24832 #define MYFW_ICMP 1 //IPPROTO_ICMP #define MYFW_TCP 6 //IPPROTO_TCP #define MYFW_UDP 17 //IPPROTO_UDP typedef struct{ unsigned int sip;//信息来源ip地址 unsigned int dip;//信息目的ip地址 unsigned short sport;//信息的发出端口 unsigned short dport;//发送信息的目的端口 unsigned short protocol;//使用的协议 unsigned short allow;//是否接收信息 }Rule; typedef struct{ unsigned int count;//表示规则的个数 Rule rule;//保存规则 }RuleTable;Makefile文件代码：
# Makefile 4.0 obj-m := myfw.o CURRENT_PATH := $(shell pwd) LINUX_KERNEL := $(shell uname -r) LINUX_KERNEL_PATH := /usr/src/linux-headers-$(LINUX_KERNEL) KBUILD_CFLAGS += -w all: make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules clean: make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
