Open×××的多处理一直都是问题，但是作为轻量级×××，这无所谓，但是如果你要将其作为重量级×××来用，那就必须考虑了。
       之前，我将Open×××分裂成了多线程版本，但是由于Open×××原本的buffer管理粒度就很粗，以至于我很难在多个线程中能够同时处理一个 multi_instance，所以我不得不采用一个multi_instance绑定一个线程的做法，为此还特意实现了一个自己版本的多队列TUN网卡 已经UDP的hash reuseport机制，这一切耦合太紧密，以至于牵一发可动全身！
       内核中的多处理是原生态的，没有被污染！原本现代千兆/万兆卡就能很好的利用多个处理器核心，这不是本文的重点，详情请参考Intel e1000e或者ixgb驱动的README。如果协议栈的softirq处理被分发到了多个CPU核心，那么在其本身来解析Open×××的协议将是一 个不错的选择，事实上我也可以在耗时的操作上去触发一个新类型的tasklet，总之能玩的东西太多，以至于我必须做出选择！
       What？在协议栈去处理Open×××协议？是的！想法是单纯的，但是如何实现呢？Netfilter上挂HOOK是一个自然而然的想法，但是这次我想 试试不同的方案。我参考了IPSec的实现，但是决不是FreeSWAN的那个实现，因为它也是基于Netfilter的！我又想参考XFRM，但是由于 IPSec的ESP/AH本身就是独立的传输层协议，因此你可以直接在第四层挂协议，而Open×××则完全不同，它是一个UDP上层的协议(我在此并没 有考虑Open××× over TCP的方案)，而Linux的协议栈处理中，UDP上面就直接传给socket了，直接进入用户态了，只好作罢。
       还好，Linux的UDP处理中有一个encap机制，也就是说你可以去注册一个encap_type，然后挂一个encap hook，叫做encap_rcv的回调函数，在里面去做掉一切。规范如下：

int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{struct udp_sock *up = udp_sk(sk);int rc;int is_udplite = IS_UDPLITE(sk);/**    Charge it to the socket, dropping if the queue is full.*/if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))goto drop;nf_reset(skb);if (up->encap_type) {/** This is an encapsulation socket so pass the skb to* the socket's udp_encap_rcv() hook. Otherwise, just* fall through and pass this up the UDP socket.* up->encap_rcv() returns the following value:* =0 if skb was successfully passed to the encap*    handler or was discarded by it.* >0 if skb should be passed on to UDP.* <0 if skb should be resubmitted as proto -N*//* if we're overly short, let UDP handle it */if (skb->len > sizeof(struct udphdr) &&up->encap_rcv != NULL) {int ret;ret = (*up->encap_rcv)(sk, skb);if (ret <= 0) {UDP_INC_STATS_BH(sock_net(sk),UDP_MIB_INDATAGRAMS,is_udplite);return -ret;}}/* FALLTHROUGH -- it's a UDP Packet */}
...//常规处理
}

好的，就是它了！也就是说，我可以在udp_queue_rcv_skb的encap_rcv中将处理流程短路，短接到哪里呢？当然 是tun网卡的netif_rx了...现在考虑反向的处理，即tun网卡的xmit到字符设备的处理，也需要类似的短路，直接将tun的xmit处理和 UDP的发送进行短接。这就是全部的框架，总图如下：

难度不大。

我又一次拿tun.c开刀了，代码直接修改了tun.c，在xmit中调用了我挂的xmit HOOK，并且通过增加一个新的ioctl命令来为一个UDP socket挂一个encap_rcv HOOK，完成两个方向的短路处理。所有的思路都以注释的方式散在代码中，补丁如下：

--- tun.c.orig  2013-11-30 13:17:30.000000000 +0800
+++ tun.c   2014-02-08 18:44:34.000000000 +0800
@@ -34,6 +34,28 @@*    Modifications for 2.3.99-pre5 kernel.*/+/*
+ * 我，又一次自私地使用了tun.c，不过这次的工作和tun本身并没有太大的关系，
+ * 只是想做一个简单的Open×××短路hack，仅此而已，我使用tun做修改是因为简单，
+ * 毕竟我只是需要将一个socket和tun联系起来，仅此而已，我需要做的就是短接
+ * UDP socket和tun网卡，仅此而已....  :)
+ *
+ * 数据通道进入内核的好处是显而易见的，多处理操作的效率由softirq分发系统决定，
+ * 而这个是简单的，在8核心处理器上，经过测试，使用Intel 82583多队列卡，按照
+ * tuple做hash中断分发，保持cache活性的基础上，也能首先Open×××协议的高速解析，
+ * 任何用户态的多线程架构与之相比都爆弱。但是此时问题浮现：
+ *
+ *  1.不是说内核态处理控制面而用户态处理数据面吗？对于Open×××，怎么反过来了啊，
+ *    有点懵了！是的，数据面放到用户态只善作个幻象，现如今不是还没有很好的实例嘛...
+ *    我并非说用户态多线程不好，只是对Open×××而言的，不信你试试。好了，在PF RING
+ *    还玩不转的时候，我只能这样，也不容易。
+ *  2.这里没有使用加密，接口是有了，但是没有高效的实现，我可不想Open×××成为Yet
+ *    Another IPSec
+ *
+ * 问题多多，marywangran@126.com，还是这个邮箱
+ *
+ **/
+#define DRV_NAME   "tun"#define DRV_VERSION    "1.6"#define DRV_DESCRIPTION    "Universal TUN/TAP device driver"
@@ -64,7 +86,19 @@#include <net/net_namespace.h>#include <net/netns/generic.h>#include <net/rtnetlink.h>
+#include <net/checksum.h>#include <net/sock.h>
+#include <net/udp.h>
+#include <linux/socket.h>
+#include <net/inet_sock.h>
+#include <linux/udp.h>
+#include <linux/ip.h>
+#include <linux/net.h>
+#include <linux/file.h>
+#include <linux/jhash.h>
+#include <linux/netfilter.h>
+#include <linux/netfilter_ipv4.h>
+#include <asm/system.h>#include <asm/uaccess.h>
@@ -82,6 +116,31 @@#define DBG1( a... )#endif+/* 定义一个Open×××封装类型 */
+#define UDP_ENCAP_O××× 20
+/* 连接一个UDP套接字和TUN网卡的ioctl命令 */
+#define TUNLINKO×××   _IOW('T', 216, int)
+/* 添加一个multi_instance的ioctl命令 */
+#define TUNADDMILTI   _IOW('T', 217, int)
+/* 为一个multi_instance添加一个虚拟地址的ioctl命令 */
+#define TUNSETMIVIP   _IOW('T', 218, int)
+/* 删除一个multi_instance的ioctl命令 */
+#define TUNDELMILTI   _IOW('T', 219, int)
+/* 设置密钥的ioctl命令 */
+#define TUNSETMKEY   _IOW('T', 220, int)
+/* 获取密钥的ioctl命令 */
+#define TUNGETMKEY   _IOW('T', 221, int)
+
+#define O×××_OPT_DEC    0
+#define O×××_OPT_ENC    1
+
+/*
+ * 用于封装ioctl命令，但不经常，也不绝对...
+ **/
+struct sockfd {
+   int fd;
+};
+#define FLT_EXACT_COUNT 8struct tap_filter {unsigned int    count;    /* Number of addrs. Zero means disabled */
@@ -97,6 +156,147 @@struct tun_sock;+
+/* UDP的encap返回正常路径 */
+#define UDP_DECAP_PASS     1
+/* UDP的encap自己消费了数据包 */
+#define UDP_DECAP_STOLEN   0
+/* 以上的规范详细情况自行看UDP处理以及IPSec/L2TP作为一个例子的实现 */
+
+/*
+ * Open×××的常量定义，我是不是该准备一个头文件和C文件呢？
+ * 借用tun.c总不是什么长久之事！tun又不是只用于Open×××啊，
+ * 然而tun.c确实该加一个HOOK机制了...
+ **/
+#define MAX_HASH_BUCKETS   256
+/* 暂时先这么多 */
+#define MAX_KEY_LENGTH      512
+#define P_DATA_V1                      6
+#define P_OPCODE_SHIFT                 3
+
+/* 这个锁的粒度有点粗 */
+DEFINE_SPINLOCK(o***_lock);
+
+typedef u32 packet_id_type;
+typedef u32 net_time_t ;
+
+/*
+ * 使用IP地址/端口对建立multi_instance
+ **/
+struct instance_req {
+    u32 real_addr;
+    __be16 port;
+};
+
+/*
+ * 为一个multi_instance添加一个虚拟IP地址，此结构体目前仅适用于
+ * TUN模式。因为对于TAP模式需要实现一个列表，基于该列表实现一个
+ * 虚拟交换机，哦，是的，虚拟交换机...
+ * */
+struct instance_vreq {
+    u32 real_addr;
+    u32 vaddr;
+    __be16 port;
+};
+
+/* 用于向内核传递密钥或者反过来传递密钥 */
+/* 是不是应该用PF_KEY啊，小小说不能，我就不用了 */
+struct key_block {
+    struct instance_req ir;
+    unsigned char key1[MAX_KEY_LENGTH];
+    unsigned char key2[MAX_KEY_LENGTH];
+    unsigned char key3[MAX_KEY_LENGTH];
+    unsigned char key4[MAX_KEY_LENGTH];
+};
+
+/*
+ * 用于实现Open×××的防重放机制
+ **/
+struct packet_id_send
+{
+   packet_id_type id;
+   time_t time;
+};
+
+/*
+ * 用于实现Open×××的防重放机制，但是天啊...里面的字段在协议移植阶段
+ * 是没有任何用武之地的，是的，没有用...
+ * */
+struct packet_id_rec
+{
+   time_t last_reap;           /* last call of packet_id_reap */
+   time_t time;                /* highest time stamp received */
+   packet_id_type id;          /* highest sequence number received */
+   int seq_backtrack;          /* set from --replay-window */
+   int time_backtrack;         /* set from --replay-window */
+   int max_backtrack_stat;     /* maximum backtrack seen so far */
+   int initialized;           /* true if packet_id_init was called */
+   struct seq_list *seq_list;  /* packet-id "memory" */
+   const char *name;
+   int unit;
+};
+
+/*
+ * 用于实现Open×××的防重放机制，目前的版本仅仅是为了例行公事，发送前
+ * 在Open×××头中封装一个递增的packet ID，但是注意，不支持LONG FORM！！
+ * */
+struct packet_id
+{
+   struct packet_id_send send;
+   struct packet_id_rec rec;
+};
+
+/*
+ * 万恶又万能的multi_instance，是不是有点熟悉呢？？对！This is it!
+ * */
+struct multi_instance {
+   struct list_head list;
+   struct hlist_node rhnode;
+   struct hlist_node vhnode;
+   struct sock *sk;
+   struct packet_id packet_id;
+   u32 saddr;
+   u32 daddr;
+   unsigned char hsaddr[ETH_ALEN];
+   /* for a learning Vswitch , it is a list! TODO */
+   unsigned char hdaddr[ETH_ALEN];
+   u32 real_saddr;
+   u32 real_daddr;
+   __be16 dport;
+    void (*mi_destroy)(struct multi_instance *);
+};
+
+/*
+ * 我的本意并不是移植Open×××，而是实现一个新的协议，but，but，but，but
+ * 苦于没有客户端，我为何不使用现成的Open×××呢？？它的协议足够简单啊足够简单！
+ * */
+struct encap_context {
+   struct hlist_head hash[MAX_HASH_BUCKETS];
+   struct hlist_head vhash[MAX_HASH_BUCKETS];
+    /* 最终还是说服了自己，解除了Open×××和tun之间的耦合 :) */
+   int (*encap_xmit)(struct tun_struct *tun, struct sk_buff *skb);
+    /* 我并没有区分cipher和auth，也就是说，我把加密运算和HMAC统一使用一套回调函数完成 :>| */
+   int (*cipher_init)(void *arg);
+   int (*cipher_enc)(struct sk_buff *skb, void *arg);
+   int (*cipher_fini)(void *arg);
+};
+
+/*
+ * 就是它！这就是Open×××协议的本质！瞧瞧看吧，你仅仅需要设置3个字段足矣！
+ * ocode:这个字段其实包含以下两个部分
+ *      opt     :很显然，我在内核中只处理数据通道，那么它是P_DATA_V1常量
+ *      key_id  :这个keyid用于切换密钥。目前使用定值0，即版本0.1不支持密钥重协商，
+ *              然则这只是个开始...
+ * id: 此字段用于封装将要发送的数据包的ID，防重放***
+ * 可见，关键的关键就是如何填充以下结构体的问题...对了，我可以说填充UDP头和IP头不是个事儿
+ * 吗？如果它们都成了事儿，还怎么好意思说自己比较喜欢折腾内核协议栈呢... :(
+ **/
+struct o***hdr {
+   u8 ocode;
+   packet_id_type id;
+    /* 注意，不要按照最长字段自然对齐，这是在玩网络，而不是内存！ */
+} __attribute__((packed));
+struct tun_struct {struct tun_file     *tfile;unsigned int        flags;
@@ -108,6 +308,11 @@struct tap_filter       txflt;struct socket       socket;
+   struct sock     *encap_sock;
+   /* pass THIS into encap_xmit like OO ?? */
+    /* 对于这个回调函数，我该说些什么呢？实际上，我真的该将其放在encap_context里面 */
+   /* int (*encap_xmit)(struct tun_struct *tun, struct sk_buff *skb);*/
+   struct encap_context ctx;#ifdef TUN_DEBUGint debug;
@@ -119,6 +324,497 @@struct tun_struct   *tun;};+/*
+ * 这个destroy函数用于清理一个multi_instance，一个析构
+ **/
+void o***_destroy(struct multi_instance *mi)
+{
+    return;
+}
+
+/*
+ * 根据一个IP地址和端口删除一个multi_instance
+ **/
+static void o***_del_real_instance(    struct tun_struct *tun,
+                   u32 real_addr,
+                   __be16 port)
+{
+   struct multi_instance *tmi;
+   struct multi_instance *mi;
+   struct hlist_node *node;
+   unsigned int hash = jhash_2words(real_addr, port, 0);
+
+   spin_lock_bh(&o***_lock);
+   hlist_for_each_entry(tmi, node, &tun->ctx.hash[hash % MAX_HASH_BUCKETS], rhnode) {
+       if (real_addr == tmi->real_daddr &&
+           port == tmi->dport) {
+           mi = tmi;
+       }
+   }
+   if (!mi) {
+       spin_unlock_bh(&o***_lock);
+       return ;
+   }
+   hlist_del(&mi->rhnode);
+   hlist_del(&mi->vhnode);
+   spin_unlock_bh(&o***_lock);
+   kfree(mi);
+}
+
+/*
+ * 添加一个multi_instance
+ **/
+static struct multi_instance *o***_add_real_instance(  struct tun_struct *tun,
+                   u32 real_addr,
+                   __be16 port)
+{
+   struct multi_instance *ret = NULL;
+   struct multi_instance *tmi;
+   struct hlist_node *node;
+   unsigned int hash = jhash_2words(real_addr, port, 0);
+
+   spin_lock_bh(&o***_lock);
+   hlist_for_each_entry(tmi, node, &tun->ctx.hash[hash % MAX_HASH_BUCKETS], rhnode) {
+       if (real_addr == tmi->real_daddr &&
+           port == tmi->dport) {
+           spin_unlock_bh(&o***_lock);
+           return tmi;
+       }
+   }
+   ret = kzalloc(sizeof(struct multi_instance), GFP_ATOMIC);
+   if (!ret) {
+       spin_unlock_bh(&o***_lock);
+       return NULL;
+   }
+   ret->dport = port;
+   ret->real_daddr = real_addr;
+   ret->sk = tun->encap_sock;
+   ret->mi_destroy = o***_destroy;
+   ret->real_saddr = inet_sk(ret->sk)->saddr;
+   hash = jhash_2words(ret->real_daddr, ret->dport, 0);
+    INIT_HLIST_NODE(&ret->rhnode);
+    INIT_HLIST_NODE(&ret->vhnode);
+   hlist_add_head(&ret->rhnode, &tun->ctx.hash[hash % MAX_HASH_BUCKETS]);
+   spin_unlock_bh(&o***_lock);
+   return ret;
+}
+
+/*
+ * 为一个multi_instance添加一个虚拟IP地址，这个本来应该实现成一个虚拟交换机的
+ * BUT对于TUN模式而言，我采用了替换模式，也就是说，我的这个版本并不支持iroute
+ * 不支持又怎么样呢？早晚的事吧。希望，真心希望James Yonan不要打我哦。。。
+ **/
+static int o***_add_virtual_instance(  struct tun_struct *tun,
+                   u32 real_addr,
+                   __be16 port,
+                   u32 addr)
+{
+   struct multi_instance *mi;
+   struct multi_instance *tmi;
+   struct hlist_node *node;
+   unsigned int hash = jhash_2words(real_addr, port, 0);
+
+   spin_lock_bh(&o***_lock);
+   hlist_for_each_entry(tmi, node, &tun->ctx.hash[hash % MAX_HASH_BUCKETS], rhnode) {
+       if (real_addr == tmi->real_daddr &&
+           port == tmi->dport) {
+           mi = tmi;
+           break;
+       }
+   }
+   if (!mi) {
+       spin_unlock_bh(&o***_lock);
+       return -1;
+   }
+   hlist_del_init(&mi->vhnode);
+   mi->daddr = addr;
+   hash = jhash_1word(mi->daddr, 0);
+   hlist_add_head(&mi->vhnode, &tun->ctx.vhash[hash % MAX_HASH_BUCKETS]);
+   spin_unlock_bh(&o***_lock);
+   return 0;
+}
+
+static int o***_pre_endecrypt(int mode,
+                            struct tun_struct *tun,
+                            struct sk_buff *skb,
+                            struct multi_instance *mi)
+{
+   u8 *data;
+   u8 ocode = 0;
+    int ret = 0;
+   int op;
+    if (mode == O×××_OPT_DEC) {
+       data = skb->data;
+       ocode = data[0];
+       op = ocode >> P_OPCODE_SHIFT;
+       if (op != P_DATA_V1) {
+            ret = -1;
+           goto out;
+       }
+    } else if (mode == O×××_OPT_ENC){
+
+    } else {
+        ret = -1;
+        goto out;
+    }
+out:
+    return ret;
+}
+
+static int o***_endecrypt(int mode,
+                            struct tun_struct *tun,
+                            struct sk_buff *skb,
+                            struct multi_instance *mi)
+{
+
+    /* return tun->ctx.endecrypt(tun, skb); */
+    return 0;
+}
+
+struct o***hdr *o***_hdr(struct sk_buff *skb)
+{
+   return (struct o***hdr*)(skb->data);
+}
+
+static int o***_post_endecrypt(int mode,
+                                struct tun_struct *tun,
+                                struct sk_buff *skb,
+                                struct multi_instance *mi)
+{
+    int ret = 0;
+    struct o***hdr *ohdr;
+    if (mode == O×××_OPT_ENC) {
+       ohdr = o***_hdr(skb);
+       ++mi->packet_id.send.id;
+       ohdr->id = htonl(mi->packet_id.send.id);
+       ohdr->ocode = (P_DATA_V1 << P_OPCODE_SHIFT) | 0x0;
+    } else if (mode == O×××_OPT_DEC) {
+    } else {
+        ret = -1;
+        goto out;
+    }
+out:
+    return ret;
+}
+
+/*
+ * 真正的亡灵序曲在这里大肆打折！
+ * 它截取了UDP的receive处理流程，它可以自行处理数据包，也可以将数据包返回给正常的UDP receive流程
+ * 点赞的说，它就是一个UDP Netfilter，或者叫做UDPFilter更好！它也有自己的规范：
+ *
+         * This is an encapsulation socket so pass the skb to
+         * the socket's udp_encap_rcv() hook. Otherwise, just
+         * fall through and pass this up the UDP socket.
+         * up->encap_rcv() returns the following value:
+         * =0 if skb was successfully passed to the encap
+         *      handler or was discarded by it.
+         * >0 if skb should be passed on to UDP.
+         * <0 if skb should be resubmitted as proto -N
+         *
+ * 有点蹩脚，但是毕竟是一种HOOK机制，实用主义者会说，就是它了！
+ */
+static int o***_data_channel_decap_recv(struct sock *sk, struct sk_buff *skb)
+{
+   struct tun_struct *tun = NULL;
+    struct multi_instance *mi = NULL;
+   struct multi_instance *tmi;
+    struct hlist_node *node;
+   struct iphdr *hdr = ip_hdr(skb);
+   struct udphdr *ud = udp_hdr(skb);
+   int ret = UDP_DECAP_PASS;
+   u32 addr = hdr->daddr;
+    __be16 port = ud->source;
+   unsigned int hash = jhash_2words(addr, port, 0);
+
+   tun = (struct tun_struct *)sk->sk_user_data;
+
+
+    spin_lock_bh(&o***_lock);
+   hlist_for_each_entry(tmi, node, &tun->ctx.hash[hash % MAX_HASH_BUCKETS], rhnode) {
+       if (addr == tmi->real_daddr &&
+                port == tmi->dport) {
+           mi = tmi;
+           break;
+       }
+   }
+   spin_unlock_bh(&o***_lock);
+    if (!mi) {
+        goto out;
+    }
+
+   skb_pull(skb, sizeof(struct udphdr));
+
+    /* decrypt
+     * 很显然，这是关键！数据解密！
+     * 但是谁能告诉我内核中怎么高效使用加解密，如果不能高效，
+     * 那么起码保证灵活，就像OpenSSL那样！进入了内核态，我突然
+     * 突然想到了OpenSSL的好，人，不能忘本啊  :<
+     */
+
+    /* 首先，判断是否是数据通道，进行例行检查，获取必要的密钥套件 */
+    if (o***_pre_endecrypt(O×××_OPT_DEC, tun, skb, mi)) {
+       skb_push(skb, sizeof(struct udphdr));
+        goto out;
+    }
+
+    /* 实际的解密操作，注意在内部可能要进行skb的realloc操作 */
+    if (o***_endecrypt(O×××_OPT_DEC, tun, skb, mi)) {
+       skb_push(skb, sizeof(struct udphdr));
+        goto out;
+    }
+
+    /* 参考Open×××的post decrypt操作 */
+    if (o***_post_endecrypt(O×××_OPT_DEC, tun, skb, mi)) {
+       skb_push(skb, sizeof(struct udphdr));
+        goto out;
+    }
+
+    /* 解密完成，推进一个Open×××头的长度 */
+   skb_pull(skb, sizeof(struct o***hdr));
+   switch (tun->flags & TUN_TYPE_MASK) {
+       case TUN_TUN_DEV:
+            switch (skb->data[0] & 0xf0) {
+                /* 当前只支持IPv4 */
+                case 0x40:
+                    break;
+                default:
+                   skb_push(skb, sizeof(struct o***hdr));
+                   skb_push(skb, sizeof(struct udphdr));
+                   goto out;
+
+           }
+           skb_reset_mac_header(skb);
+            /* 是时候丢掉西装外衣了，口袋里的通行证会将你引入深渊，
+             * 不信的话，注释此言，在Open×××客户端机器上ping一下
+             * 服务端的虚拟IP试一试
+             **/
+            skb_dst_drop(skb);
+           skb->protocol = htons(ETH_P_IP);;
+           skb->dev = tun->dev;
+           ret = UDP_DECAP_STOLEN;
+           break;
+       case TUN_TAP_DEV:
+           // TODO
+           goto out;
+           break;
+   }
+    /* 模拟TUN虚拟网卡接收，此时截获处理正式完成，
+     * 告诉UDP，嗨，你的数据我已经帮你处理了
+     **/
+   netif_rx_ni(skb);
+
+out:
+   return ret;
+}
+
+/*
+ * 封装UDP
+ * 本来想直接调用socket的sendto/sendmsg的，然而太过恶心与繁琐，加之需要skb和msg之间的拷贝
+ * 为了省事而影响效率这样不值！还是自己封装吧，反正也不难
+ **/
+static int encap_udp(struct sk_buff *skb, struct multi_instance *mi, unsigned int *pdlen)
+{
+   struct udphdr *uh;
+   struct inet_sock *inet = inet_sk(mi->sk);
+   int len = *pdlen + sizeof(struct udphdr);
+
+   skb_push(skb, sizeof(struct udphdr));
+   skb_reset_transport_header(skb);
+
+   uh = udp_hdr(skb);
+   uh->source = htons(inet->num);
+   uh->dest = mi->dport;
+   uh->len = htons(len);
+   uh->check = 0;
+
+    /* 注意这里有优化空间，ufo是否启用，硬件是否能帮我计算checksum呢？？ */
+    uh->check = 0;
+   uh->check = csum_tcpudp_magic(mi->real_saddr, mi->real_daddr, len,
+                     mi->sk->sk_protocol, csum_partial(uh,
+                                                        len,
+                                                        0));
+
+   return 0;
+}
+
+/*
+ * IP层的封装与发送函数，注意，这里很不方便使用ip_queue_xmit
+ **/
+static int encap_ip_xmit(struct sk_buff *skb, struct multi_instance *mi, struct iphdr *old)
+{
+   struct iphdr *iph;
+   struct dst_entry *dst;
+
+   skb_push(skb, sizeof(struct iphdr));
+    /* 如影随形 */
+   skb_reset_network_header(skb);
+
+   iph = ip_hdr(skb);
+   iph->version        =   4;
+   iph->ihl        =   sizeof(struct iphdr)>>2;
+   iph->frag_off       =   old->frag_off;
+   iph->protocol       =   IPPROTO_UDP;
+   iph->tos        =   old->tos;
+   iph->daddr      =   mi->real_daddr;
+   iph->saddr      =   mi->real_saddr;
+   iph->ttl        =   old->ttl;
+    /* 这个reroute频繁用于OUTPUT Netfilter HOOK，但问Rusty本人，
+     * Netfilter的OUTPUT设计为何如何之好 */
+   if (ip_route_me_harder(skb, RTN_LOCAL)!= 0) {
+       return -1;
+   }
+   dst = skb_dst(skb);
+
+   ip_select_ident(iph, dst, NULL);
+   return ip_local_out(skb);
+}
+
+
+static int encap_o***(struct sk_buff *skb, struct multi_instance *mi, int *pdlen)
+{
+    struct tun_struct *tun;
+    int ret = 0;
+
+
+    if (!mi) {
+        ret = -1;
+        goto out;
+    }
+
+    tun = mi->sk->sk_user_data;
+    if (!tun) {
+        ret = -1;
+        goto out;
+    }
+
+    /* encrypt
+     * 很显然，这是关键！数据解密！
+     * 但是谁能告诉我内核中怎么高效使用加解密，如果不能高效，
+     * 那么起码保证灵活，就像OpenSSL那样！进入了内核态，我突然
+     * 突然想到了OpenSSL的好，人，不能忘本啊  :<
+     */
+
+    /* 首先，判断是否是数据通道，进行例行检查，获取必要的密钥套件 */
+    if (o***_pre_endecrypt(O×××_OPT_ENC, tun, skb, mi)) {
+        ret = -1;
+        goto out;
+    }
+
+    /* 实际的解密操作，注意在内部可能要进行skb的realloc操作 */
+    if (o***_endecrypt(O×××_OPT_ENC, tun, skb, mi)) {
+        ret = -1;
+        goto out;
+    }
+
+    /* 如影随形 */
+   skb_push(skb, sizeof(struct o***hdr));
+    *pdlen += sizeof(struct o***hdr);
+
+    /* 参考Open×××的post decrypt操作 */
+    if (o***_post_endecrypt(O×××_OPT_ENC, tun, skb, mi)) {
+        ret = -1;
+       skb_pull(skb, sizeof(struct o***hdr));
+        goto out;
+    }
+
+out:
+   return ret;
+}
+
+/*
+ * hard_xmit中的封装函数，用于短路处理
+ **/
+static int o***_data_channel_encap_xmit(struct tun_struct *tun, struct sk_buff *skb)
+{
+   unsigned int max_headroom;
+    int ret = 0;
+   struct sock *sk;
+   struct multi_instance *mi = NULL;
+   struct hlist_node *node;
+   struct iphdr *old_iphdr = NULL;
+    unsigned int dlen = skb->len;
+
+   sk = tun->encap_sock;
+   if (!sk) {
+        ret = -1;
+       goto out;
+   }
+   if (sk->sk_protocol != IPPROTO_UDP) {
+        ret = -1;
+       goto out;
+   }
+
+#define I_THINK_THIS_LENGTH_ENOUGH_BECAUSE_OF_XXX  40
+   max_headroom = (I_THINK_THIS_LENGTH_ENOUGH_BECAUSE_OF_XXX +
+                    LL_RESERVED_SPACE(tun->dev)         +
+                   sizeof(struct iphdr)                +
+                   sizeof(struct udphdr)               +
+                   sizeof(struct o***hdr));
+
+   switch (tun->flags & TUN_TYPE_MASK){
+   case TUN_TUN_DEV:
+   {
+       struct iphdr *hdr = ip_hdr(skb);
+       u32 addr = hdr->daddr;
+       struct multi_instance *tmi;
+       unsigned int hash = jhash_1word(addr, 0);
+
+       old_iphdr = hdr;
+       spin_lock_bh(&o***_lock);
+       hlist_for_each_entry(tmi, node, &tun->ctx.vhash[hash % MAX_HASH_BUCKETS], vhnode) {
+           if (addr == tmi->daddr) {
+               mi = tmi;
+               break;
+           }
+       }
+       spin_unlock_bh(&o***_lock);
+   }
+       break;
+   case TUN_TAP_DEV:
+   {
+       // TODO
+        ret = -1;
+
+   }
+       break;
+
+   }
+   if (!mi) {
+        ret = -1;
+       goto out;
+   }
+   if (skb_headroom(skb) < max_headroom || !skb_clone_writable(skb, 0)) {
+       struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
+       if (!new_skb) {
+            ret = -1;
+           goto out;
+       }
+        skb_dst_set(new_skb, skb_dst(skb));
+
+       dev_kfree_skb(skb);
+       skb = new_skb;
+   }
+
+   if (encap_o***(skb, mi, &dlen)) {
+        ret = 1;
+        dev_kfree_skb(skb);
+        goto out;
+    }
+
+   if (encap_udp(skb, mi, &dlen)) {
+        dev_kfree_skb(skb);
+        ret = 1;
+        goto out;
+    }
+   /* GO AWAY?? 注意返回值转换 */
+   ret = encap_ip_xmit(skb, mi, old_iphdr);
+    if (ret < 0) {
+        ret = 1;
+    }
+out:
+   return ret;
+}
+static inline struct tun_sock *tun_sk(struct sock *sk){return container_of(sk, struct tun_sock, sk);
@@ -155,8 +851,38 @@static void __tun_detach(struct tun_struct *tun){
+    struct sock *sk;/* Detach from net device */netif_tx_lock_bh(tun->dev);
+    /**/
+    sk = tun->encap_sock;
+    if (sk) {
+        int i;
+       /* 重置操作 */
+       (udp_sk(sk))->encap_type = 0;
+       (udp_sk(sk))->encap_rcv = NULL;
+       sk->sk_user_data = NULL;
+       tun->encap_sock = NULL;
+       tun->ctx.encap_xmit = NULL;
+        for (i = 0; i < MAX_HASH_BUCKETS; i++) {
+            struct multi_instance *mi;
+            struct hlist_head *head;
+            struct hlist_node *node, *tmp;
+            head = &tun->ctx.hash[i];
+            hlist_for_each_entry_safe(mi, node, tmp, head, rhnode) {
+                hlist_del(node);
+               hlist_del(&mi->vhnode);
+                if (mi->mi_destroy) {
+                    mi->mi_destroy(mi/* THIS ? self ? Okey,thinking in JAVA */);
+                }
+                kfree(mi);
+            }
+        }
+        /* 这里才减少引用计数！因为你并不晓得且不能假设tun和socket的关闭顺序 */
+        if (sk) {
+            sockfd_put(sk->sk_socket);
+        }
+    }tun->tfile = NULL;netif_tx_unlock_bh(tun->dev);@@ -364,6 +1090,21 @@if (!check_filter(&tun->txflt, skb))goto drop;+   /* ?? */
+   if (tun->ctx.encap_xmit) {
+
+       int ret = tun->ctx.encap_xmit(tun/*this就是那个叫做JAVA编程思想的！GEB之大成*/, skb);
+        /* Is this Okay？I don't known */
+        /* Refer to the return value of UDP encap_rcv callback!*/
+       if (ret == 0) {
+           /* encap_xmit drop skb*/
+           goto out;
+       } else if (ret > 0) {
+            goto out;
+        }
+       /* fall through */
+   }
+if (skb_queue_len(&tun->socket.sk->sk_receive_queue) >= dev->tx_queue_len) {if (!(tun->flags & TUN_ONE_QUEUE)) {/* Normal queueing mode. */
@@ -393,6 +1134,7 @@drop:dev->stats.tx_dropped++;kfree_skb(skb);
+out:return NETDEV_TX_OK;}@@ -467,6 +1209,7 @@dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */break;}
+    dev->priv_flags     &= ~IFF_XMIT_DST_RELEASE;}/* Character device part */
@@ -1140,7 +1883,7 @@if (cmd == TUNSETIFF && !tun) {ifr.ifr_name[IFNAMSIZ-1] = '\0';-       ret = (tfile->net, file, &ifr);
+       ret = tun_set_iff(tfile->net, file, &ifr);if (ret)goto unlock;
@@ -1158,6 +1901,98 @@ret = 0;switch (cmd) {
+        /* 这里的几个命令都是Open×××相关的 */
+        /* 但是我并不知道怎么将这些独立出去！*/
+   case TUNADDMILTI:
+        {
+            struct instance_req ir;
+           if (copy_from_user(&ir, argp, sizeof(ir))) {
+               ret = -EFAULT;
+               break;
+           }
+            if (!o***_add_real_instance(tun, ir.real_addr, ir.port)) {
+                ret = -EFAULT;
+                break;
+            }
+        }
+        break;
+   case TUNSETMIVIP:
+        {
+            struct instance_vreq vir;
+           if (copy_from_user(&vir, argp, sizeof(vir))) {
+               ret = -EFAULT;
+               break;
+           }
+            o***_add_virtual_instance(tun, vir.real_addr, vir.port, vir.vaddr);
+        }
+        break;
+   case TUNDELMILTI:
+        {
+            struct instance_req ir;
+           if (copy_from_user(&ir, argp, sizeof(ir))) {
+               ret = -EFAULT;
+               break;
+           }
+            o***_del_real_instance(tun, ir.real_addr, ir.port);
+        }
+        break;
+   case TUNSETMKEY:
+        {
+            struct key_block *kb;
+            /* 这里为何非要不在栈上分配呢？
+             * 因为这里是内核，内核栈的大小是有限的，鉴于kb空间较大
+             * 因此采用了动态分配，用后释放
+             **/
+            kb = kmalloc(sizeof(struct key_block), GFP_KERNEL);
+            if (!kb) {
+                ret = -ENOMEM;
+                break;
+            }
+           if (copy_from_user(kb, argp, sizeof(kb))) {
+               ret = -EFAULT;
+               break;
+           }
+            // TODO waht? find_set_key(tun, kb);
+            kfree(kb);
+        }
+        break;
+   case TUNGETMKEY:
+        // TODO
+        break;
+   case TUNLINKO×××:
+   {
+       struct sockfd sfd;
+       struct socket *sock;
+       struct sock *sk;
+       int err;
+        int i;
+       if (copy_from_user(&sfd, argp, sizeof(sfd))) {
+           ret = -EFAULT;
+           break;
+       }
+       sock = sockfd_lookup(sfd.fd, &err);
+       if (!sock) {
+           ret = -EFAULT;
+           break;
+       }
+       sk = sock->sk;
+       if (sk->sk_protocol != IPPROTO_UDP) {
+           ret = -EFAULT;
+           break;
+       }
+       (udp_sk(sk))->encap_type = UDP_ENCAP_O×××;
+       (udp_sk(sk))->encap_rcv = o***_data_channel_decap_recv;
+       /* link tun and sock ?? */
+       tun->encap_sock = sk;
+       sk->sk_user_data = tun;
+       tun->ctx.encap_xmit = o***_data_channel_encap_xmit;
+        for (i = 0; i < MAX_HASH_BUCKETS; i++) {
+            INIT_HLIST_HEAD(&tun->ctx.hash[i]);
+            INIT_HLIST_HEAD(&tun->ctx.vhash[i]);
+        }
+   }
+       break;
+case TUNGETIFF:ret = tun_get_iff(current->nsproxy->net_ns, tun, &ifr);if (ret)

将tun.c打上以上的patch后编译加载，然后修改Open×××代码：
1.在确保tun字符设备被打开以及socket创建之后触发TUNLINKO×××命令；
2.在multi_create_instance的时候触发TUNADDMILTI命令增加一个instance；
3.在向Open×××客户端推送TUN虚拟IP地址后触发TUNSETMIVIP；
4.在密钥协商完成后触发TUNSETMKEY命令。
注意，由于实际的加密/解密处理放在了第二部分，因此此时只能使用cipher none，auth none来进行测试。