增加IPv6支持

6 files changed, 273 insertions, 86 deletions

diff --git a/tunnat/include/session.h b/tunnat/include/session.h
index 1fa47da..021ffc8 100644
--- a/tunnat/include/session.h
+++ b/tunnat/include/session.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 
 #include <tunnat.h>
@@ -8,24 +8,87 @@ extern "C"
 {
 #include <MESA_htable.h>
 }
-
+/* 隧道格式类型 */
+enum key_type
+{
+    KEY_TYPE_UNKNOWN,
+    KEY_TYPE_IPV4,
+    KEY_TYPE_IPV6
+};
 class SessionEntry
 {
 public:
     TunnelContainerArray tun_array;
 };
-
-class SessionKey
+class IPV4Key
 {
 public:
     struct in_addr s_in_addr;
     struct in_addr d_in_addr;
+    IPV4Key swap()
+    {
+        IPV4Key __reverse_key4;
+        __reverse_key4.s_in_addr.s_addr = d_in_addr.s_addr;
+        __reverse_key4.d_in_addr.s_addr = s_in_addr.s_addr;
+        return __reverse_key4;
+    }
+    bool operator ==( const IPV4Key &key)
+    {
+        if ((s_in_addr.s_addr == key.s_in_addr.s_addr)
+            && (d_in_addr.s_addr == key.d_in_addr.s_addr))  return true;
+        return false;
+    }
 
+};
+class IPV6Key
+{
+public:
+    struct in6_addr s_in6_addr;
+    struct in6_addr d_in6_addr;
+    IPV6Key swap()
+    {
+        IPV6Key _reverse_key6;
+        memcpy(&(_reverse_key6.s_in6_addr), &d_in6_addr,sizeof(struct in6_addr));
+        memcpy(&(_reverse_key6.d_in6_addr), &s_in6_addr, sizeof(struct in6_addr));
+        return _reverse_key6;
+    }
+    bool operator ==(const IPV6Key &key)
+    {
+        if (memcmp(&s_in6_addr,&(key.s_in6_addr),sizeof(struct in6_addr))==0 
+            && memcmp(&d_in6_addr, &(key.d_in6_addr), sizeof(struct in6_addr)) == 0) return true;
+        return false;
+    }
+};
+
+class SessionKey
+{
+public:
+    IPV4Key ipv4_key;
+    IPV6Key ipv6_key;
+    enum key_type type;
+    SessionKey()
+    {
+        ipv4_key.s_in_addr.s_addr=0;
+        ipv4_key.d_in_addr.s_addr=0;
+        memset(&ipv6_key,0,sizeof(IPV6Key));
+        type=KEY_TYPE_UNKNOWN;
+    }
     SessionKey swap()
     {
         SessionKey _reverse_key;
-        _reverse_key.s_in_addr = d_in_addr;
-        _reverse_key.d_in_addr = s_in_addr;
+        switch (type)
+        {
+        case KEY_TYPE_IPV4:
+            _reverse_key.ipv4_key = ipv4_key.swap();
+            _reverse_key.type = KEY_TYPE_IPV4;
+            break;
+        case KEY_TYPE_IPV6:
+            _reverse_key.ipv6_key = ipv6_key.swap();
+            _reverse_key.type = KEY_TYPE_IPV6;
+            break;
+        default:
+            break;
+        }
         return _reverse_key;
     }
 };
@@ -35,14 +98,16 @@ class SessionTable
 public:
     SessionEntry * Query(SessionKey & key);
     SessionEntry * QueryDualDirect(SessionKey & key);
-    SessionEntry * QueryRecent();
+    SessionEntry * QueryRecent(enum key_type type);
 
     int Add(SessionKey & key, SessionEntry & entry);
     int Init(unsigned int nr_max_sessions, unsigned int nr_slots, unsigned int expire_time);
 
 protected:
-    MESA_htable_handle ht_table_;
-    static int htable_comp_fun_cb(const uchar * key1, uint size1, const uchar * key2, uint size2);
+    MESA_htable_handle ht_table_v4;
+    MESA_htable_handle ht_table_v6;
+    static int htable_v4_comp_fun_cb(const uchar * key1, uint size1, const uchar * key2, uint size2);
+    static int htable_v6_comp_fun_cb(const uchar * key1, uint size1, const uchar * key2, uint size2);
     static int htable_free_fun_cb(void *data);
     static int htable_expire_notify_cb(void *data, int eliminate_type);
     static int htable_iterate_recent(const uchar * key, uint size, void * data, void *user);
diff --git a/tunnat/include/tunnel.h b/tunnat/include/tunnel.h
index 1d83af0..fd2c314 100644
--- a/tunnat/include/tunnel.h
+++ b/tunnat/include/tunnel.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #include <array>
 
 extern "C"
@@ -13,14 +13,19 @@ extern "C"
 #include <marsio.h>
 #include <mrtunnat.h>
 }
-
-struct AddressInfo
+enum addr_type
+{
+    IPV4_ADDR,
+    IPV6_ADDR
+};
+struct ipv4_addr_t
 {
-    uint8_t src_mac_addr[6];
-    uint8_t dst_mac_addr[6];
-
     struct in_addr src_in_addr;
     struct in_addr dst_in_addr;
+};
+
+struct ipv6_addr_t
+{
     struct in6_addr src_in6_addr;
     struct in6_addr dst_in6_addr;
 
@@ -111,8 +116,7 @@ protected:
     struct udp_hdr udp_hdr_;
     struct g_vxlan_hdr vxlan_hdr_;
 
-    struct in_addr src_in_addr_;
-    struct in_addr dst_in_addr_;
+    struct ipv4_addr_t ipv4_addr_;
 
 public:
     int PacketParse(const char * pkt, unsigned int pkt_len);
@@ -121,14 +125,13 @@ public:
 
     int GetAddressInfo(struct AddressInfo & addr_info)
     {
-        memcpy(addr_info.src_mac_addr, &ether_hdr_.s_addr, sizeof(ether_hdr_.s_addr));
-        memcpy(addr_info.dst_mac_addr, &ether_hdr_.d_addr, sizeof(ether_hdr_.d_addr));
-
-        addr_info.src_in_addr = src_in_addr_;
-        addr_info.dst_in_addr = dst_in_addr_;
+        addr_info.type = IPV4_ADDR;
+        memcpy(&(addr_info.addr.ipv4_addr), &ipv4_addr_, sizeof(struct ipv4_addr_t)); 
         addr_info.s_port = udp_hdr_.src_port;
         addr_info.d_port = udp_hdr_.dst_port;
-        addr_info.vpn_id = (vxlan_hdr_.vlan_id_half_low & 0xf) | (vxlan_hdr_.vlan_id_half_high & 0xff) << 4;
+        addr_info.vpn_id = (vxlan_hdr_.vlan_id_half_low & 0xf) |
+            (vxlan_hdr_.vlan_id_half_high & 0xff) << 4;
+
         return 0;
     }
 
@@ -167,32 +170,40 @@ public:
 class TunInnerIPv4 : public Tunnel
 {
 protected:
-    struct in_addr src_in_addr_;
-    struct in_addr dst_in_addr_;
+    struct ipv4_addr_t ipv4_addr;
 public:
     int PacketParse(const char * pkt, unsigned int pkt_len);
 
     int GetAddressInfo(struct AddressInfo & addr_info)
     {
-        addr_info.src_in_addr = src_in_addr_;
-        addr_info.dst_in_addr = dst_in_addr_;
+        addr_info.type = IPV4_ADDR;
+        memcpy(&(addr_info.addr.ipv4_addr), &ipv4_addr, sizeof(struct ipv4_addr_t));
         return RT_SUCCESS;
     }
 
     void ReverseAddress()
     {
-        std::swap<in_addr>(src_in_addr_, dst_in_addr_);
+        std::swap<in_addr>(ipv4_addr.src_in_addr, ipv4_addr.dst_in_addr);
     }
 };
 
 class TunInnerIPv6 : public Tunnel
 {
 protected:
-    struct in6_addr src_in6_addr_;
-    struct in6_addr dst_in6_addr_;
+    struct ipv6_addr_t ipv6_addr;
 public:
     int PacketParse(const char * pkt, unsigned int pkt_len);
-    int GetAddressInfo(struct AddressInfo & addr_info);
+    int GetAddressInfo(struct AddressInfo & addr_info)
+    {
+        addr_info.type = IPV6_ADDR;
+        memcpy(&(addr_info.addr.ipv6_addr),&ipv6_addr,sizeof(struct ipv6_addr_t));
+        return RT_SUCCESS;
+    }
+    void ReverseAddress()
+    {
+        struct ipv6_addr_t ipv6_addr;
+        std::swap<in6_addr>(ipv6_addr.src_in6_addr, ipv6_addr.dst_in6_addr);
+    }
 };
 
 class TunInnerPPP : public Tunnel
diff --git a/tunnat/src/runtime.cc b/tunnat/src/runtime.cc
index 8d8d329..ea347d4 100644
--- a/tunnat/src/runtime.cc
+++ b/tunnat/src/runtime.cc
@@ -16,6 +16,13 @@ extern "C"
 #define MR_TUNNAT_USE_PHONY_ETHER_HEADER    1
 #endif
 
+#ifndef IPV4_VERSION
+#define IPV4_VERSION 0x04
+#endif
+
+#ifndef IPV6_VERSION
+#define IPV6_VERSION 0X06
+#endif
 static int __phy_to_virt_pkt_decap(TunnatInstance * instance, TunnatThreadInstance * th_instance,
     marsio_buff_t * mbuf, TunnelContainerArray & tun_array)
 {
@@ -64,11 +71,23 @@ static int __phy_to_virt_session_check(TunnatInstance * instance, TunnatThreadIn
 
     int ret = tun_array.GetInnerTunContainer().GetAddressInfo(addr_info);
     if (ret < 0) return RT_ERR;
-
-    memset(&session_key, 0, sizeof(struct SessionKey));
-    session_key.s_in_addr = addr_info.src_in_addr;
-    session_key.d_in_addr = addr_info.dst_in_addr;
-
+	switch(addr_info.type)
+	{
+	case IPV4_ADDR:
+		session_key.type=KEY_TYPE_IPV4;
+		session_key.ipv4_key.s_in_addr.s_addr=addr_info.addr.ipv4_addr.src_in_addr.s_addr;
+		session_key.ipv4_key.d_in_addr.s_addr=addr_info.addr.ipv4_addr.dst_in_addr.s_addr;
+		break;
+	case IPV6_ADDR:
+		session_key.type=KEY_TYPE_IPV6;
+		memcpy(&session_key.ipv6_key.s_in6_addr,&addr_info.addr.ipv6_addr.src_in6_addr,sizeof(struct in6_addr));
+		memcpy(&session_key.ipv6_key.d_in6_addr,&addr_info.addr.ipv6_addr.dst_in6_addr,sizeof(struct in6_addr));
+		break;
+	default:
+		assert(0);
+		break;
+	}
+   
     /* 查询当前会话表 */
     SessionEntry * ss_entry = th_instance->ss_table->Query(session_key);
     if (ss_entry != NULL) return RT_SUCCESS;
@@ -109,9 +128,10 @@ static int __phy_to_virt_pkt_modify(TunnatInstance * instance, TunnatThreadInsta
     AddressInfo outer_tunnel_addrinfo;
     if (outer_tunnel.GetAddressInfo(outer_tunnel_addrinfo) == RT_SUCCESS)
     {
-        memcpy(ctrlzone->g_device_mac, outer_tunnel_addrinfo.src_mac_addr, sizeof(ctrlzone->g_device_mac));
+    	assert(outer_tunnel_addrinfo.type==IPV4_ADDR);
+		memcpy(ctrlzone->g_device_mac, outer_tunnel_addrinfo.src_mac_addr, sizeof(ctrlzone->g_device_mac));
         memcpy(ctrlzone->l_device_mac, outer_tunnel_addrinfo.dst_mac_addr, sizeof(ctrlzone->l_device_mac));
-        ctrlzone->g_device_in_addr = outer_tunnel_addrinfo.src_in_addr.s_addr;
+        ctrlzone->g_device_in_addr = outer_tunnel_addrinfo.addr.ipv4_addr.src_in_addr.s_addr;
         ctrlzone->l4_src_port = outer_tunnel_addrinfo.s_port;
         ctrlzone->g_device_vpn_id = outer_tunnel_addrinfo.vpn_id;
     }
@@ -250,6 +270,21 @@ static int __virt_to_phy_pkt_encap(TunnatInstance * instance, TunnatThreadInstan
 
 #if MR_TUNNAT_USE_PHONY_ETHER_HEADER
 
+	SessionKey ss_key;
+	struct ether_hdr *ether_hdr=(struct ether_hdr *)marsio_buff_mtod(mbuf);
+	switch(ntohs(ether_hdr->ether_type))
+	{
+	case ETHER_TYPE_IPv4:
+		ss_key.type=KEY_TYPE_IPV4;
+		break;
+	case ETHER_TYPE_IPv6:
+		ss_key.type=KEY_TYPE_IPV6;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+
     /* 去掉以太网头部，因为是应用自己造的包，所以没有备份的以太网类型数据 */
     /* 使用写时复制的报文修改接口，因为此时报文可能被其他人引用 */
 
@@ -261,18 +296,33 @@ static int __virt_to_phy_pkt_encap(TunnatInstance * instance, TunnatThreadInstan
 
 #endif
 
-    //TODO: IPv6 Support
-    struct SessionKey ss_key;
-    struct ipv4_hdr * ipv4_hdr = (struct ipv4_hdr *)marsio_buff_mtod(mbuf);
-    ss_key.s_in_addr.s_addr = ipv4_hdr->src_addr;
-    ss_key.d_in_addr.s_addr = ipv4_hdr->dst_addr;
+	switch(ss_key.type)
+	{
+	case KEY_TYPE_IPV4:
+	{
+		struct ipv4_hdr *ipv4_hdr = (struct ipv4_hdr *)marsio_buff_mtod(mbuf);
+		ss_key.ipv4_key.s_in_addr.s_addr=ipv4_hdr->src_addr;
+		ss_key.ipv4_key.d_in_addr.s_addr=ipv4_hdr->dst_addr;
+		break;
+	}
+	case KEY_TYPE_IPV6:
+	{
+		struct ipv6_hdr *ipv6_hdr = (struct ipv6_hdr *)marsio_buff_mtod(mbuf);
+		memcpy(&ss_key.ipv6_key.s_in6_addr,ipv6_hdr->src_addr,sizeof(struct in6_addr));
+		memcpy(&ss_key.ipv6_key.d_in6_addr,ipv6_hdr->dst_addr,sizeof(struct in6_addr));
+		break;
+	}
+	default:
+		assert(0);
+		break;
+	} 
 
     /* 双向查询 */
     SessionEntry * ss_entry = th_instance->ss_table->QueryDualDirect(ss_key);
     if (ss_entry != NULL) goto session_realy;
     
     /* 没有查询到，使用最近的一次隧道数据，随便找到一个专用设备回注 */
-    ss_entry = th_instance->ss_table->QueryRecent();
+    ss_entry = th_instance->ss_table->QueryRecent(ss_key.type);
     if (ss_entry != NULL)
     {
         TUNNAT_THREAD_STAT_ADD(TUNNAT_STAT_ENCAP_USE_RECENT_SESSION, 1);
diff --git a/tunnat/src/session.cc b/tunnat/src/session.cc
index 51c1810..bb6938f 100644
--- a/tunnat/src/session.cc
+++ b/tunnat/src/session.cc
@@ -1,10 +1,22 @@
-#include <session.h>
-
+#include <session.h>
+#include<arpa/inet.h>
 SessionEntry * SessionTable::Query(SessionKey & key)
 {
-    SessionEntry * ss_entry = static_cast<SessionEntry *>
-        (MESA_htable_search(ht_table_, (const unsigned char *)&key, sizeof(SessionKey)));
-
+    SessionEntry * ss_entry = nullptr;
+	switch(key.type)
+	{
+	case KEY_TYPE_IPV4:
+		ss_entry = static_cast<SessionEntry *>
+            (MESA_htable_search(ht_table_v4, (const unsigned char *)&(key.ipv4_key), sizeof(IPV4Key)));
+		break;
+	case KEY_TYPE_IPV6:
+		ss_entry = static_cast<SessionEntry *>
+            (MESA_htable_search(ht_table_v6, (const unsigned char *)&(key.ipv6_key), sizeof(IPV6Key)));
+		break;
+	default: 
+		assert(0);
+		break;
+	}
     return ss_entry;
 }
 
@@ -37,14 +49,25 @@ reverse_dir:
     return ss_entry;
 }
 
-SessionEntry * SessionTable::QueryRecent()
+SessionEntry * SessionTable::QueryRecent(enum key_type type)
 {
     SessionEntry * ss_entry = NULL;
     
     /* 查找最近使用的隧道配置 */
-    MESA_htable_iterate_bytime(ht_table_, ITERATE_TYPE_NEWEST_FIRST, 
+	switch(type)
+	{
+	case KEY_TYPE_IPV4:
+		MESA_htable_iterate_bytime(ht_table_v4, ITERATE_TYPE_NEWEST_FIRST, 
         htable_iterate_recent, (void *)&ss_entry);
-
+		break;
+	case KEY_TYPE_IPV6:
+		MESA_htable_iterate_bytime(ht_table_v6, ITERATE_TYPE_NEWEST_FIRST, 
+        htable_iterate_recent, (void *)&ss_entry);
+		break;
+	default:
+		assert(0);
+		break;
+	}
     if (ss_entry == NULL) return NULL;
     return ss_entry;
 }
@@ -55,15 +78,26 @@ int SessionTable::Add(SessionKey & key, SessionEntry & entry)
     *ss_entry = entry;
 
     TUNNAT_THREAD_STAT_ADD(TUNNAT_STAT_SESSION_ADD, 1);
-    int ret = MESA_htable_add(ht_table_, (const unsigned char *)&key, sizeof(SessionKey), ss_entry);
-
+    int ret = 0;
+	switch(key.type)
+	{
+	case KEY_TYPE_IPV4:
+		ret = MESA_htable_add(ht_table_v4, (const unsigned char *)&(key.ipv4_key), sizeof(IPV4Key), ss_entry);
+		break;
+	case KEY_TYPE_IPV6:
+		ret = MESA_htable_add(ht_table_v6, (const unsigned char *)&(key.ipv6_key), sizeof(IPV6Key), ss_entry);
+		break;
+	default:
+		assert(0);
+		break;
+	}
     assert(ret >= 0);
     return ret;
 }
 
-int SessionTable::Init(unsigned int nr_max_sessions, unsigned int nr_slots, unsigned int expire_time)
+MESA_htable_handle init_htable(unsigned int nr_max_sessions, unsigned int nr_slots, unsigned int expire_time,void * fn_data_free_cb,void * fn_expire_notify_cb,void * fn_cmp_cb)
 {
-    unsigned int opt_int;
+	unsigned int opt_int;
     MESA_htable_handle htable = MESA_htable_born();
     assert(htable != NULL);
 
@@ -91,34 +125,46 @@ int SessionTable::Init(unsigned int nr_max_sessions, unsigned int nr_slots, unsi
     opt_int = HASH_ELIMINATE_ALGO_LRU;
     MESA_htable_set_opt(htable, MHO_ELIMIMINATE_TYPE, &opt_int, sizeof(int));
 
-    void * fn_cmp_cb = (void *)htable_comp_fun_cb;
     MESA_htable_set_opt(htable, MHO_CBFUN_KEY_COMPARE, fn_cmp_cb, sizeof(fn_cmp_cb));
 
-    void * fn_data_free_cb = (void *)htable_free_fun_cb;
     MESA_htable_set_opt(htable, MHO_CBFUN_DATA_FREE, fn_data_free_cb, sizeof(fn_data_free_cb));
 
-    void * fn_expire_notify_cb = (void *)htable_expire_notify_cb;
     MESA_htable_set_opt(htable, MHO_CBFUN_DATA_EXPIRE_NOTIFY, fn_expire_notify_cb, sizeof(fn_expire_notify_cb));
 
     int ret = MESA_htable_mature(htable);
     if (ret < 0)
     {
         MR_ERROR("Creating session table failed: MESA htable mature error, "
-            "errno = %d", ret); return ret;
+            "errno = %d", ret); 
+		assert(0);
     }
-
-    ht_table_ = htable;
+   return htable;
+}
+int SessionTable::Init(unsigned int nr_max_sessions, unsigned int nr_slots, unsigned int expire_time)
+{
+	ht_table_v4 =init_htable(nr_max_sessions,nr_slots,expire_time,(void *)htable_free_fun_cb,(void *)htable_expire_notify_cb,(void *)htable_v4_comp_fun_cb);
+	ht_table_v6 =init_htable(nr_max_sessions,nr_slots,expire_time,(void *)htable_free_fun_cb,(void *)htable_expire_notify_cb,(void *)htable_v6_comp_fun_cb);
     return RT_SUCCESS;
 }
-
-int SessionTable::htable_comp_fun_cb(const uchar * key1, uint size1, const uchar * key2, uint size2)
+int SessionTable::htable_v6_comp_fun_cb(const uchar * key1, uint size1, const uchar * key2, uint size2)
 {
-    SessionKey * __key1 = (SessionKey *)key1;
-    SessionKey * __key2 = (SessionKey *)key2;
+    IPV6Key* __key1 = (IPV6Key *)key1;
+    IPV6Key * __key2 = (IPV6Key *)key2;
+    if ((*__key1) == (*__key2))
+   	{
+   		return 0;
+    }  
+    return 1;
+}
 
-    if ((__key1->s_in_addr.s_addr == __key2->s_in_addr.s_addr)
-        && (__key1->d_in_addr.s_addr == __key2->d_in_addr.s_addr)) return 0;
-       
+int SessionTable::htable_v4_comp_fun_cb(const uchar * key1, uint size1, const uchar * key2, uint size2)
+{
+    IPV4Key * __key1 = (IPV4Key *)key1;
+    IPV4Key * __key2 = (IPV4Key *)key2;
+    if ((*__key1) == (*__key2))
+    {
+    	return 0;
+    }  	
     return 1;
 }
 
diff --git a/tunnat/src/tunnel.cc b/tunnat/src/tunnel.cc
index f78136e..f7038c9 100644
--- a/tunnat/src/tunnel.cc
+++ b/tunnat/src/tunnel.cc
@@ -1,4 +1,4 @@
-
+
 extern "C"
 {
 #include <rte_ether.h>
@@ -65,8 +65,8 @@ int TunVxlan::PacketParse(const char * pkt, unsigned int pkt_len)
     vxlan_hdr_ = *vxlan_hdr;
     udp_hdr_ = *udp_hdr;
     
-    src_in_addr_.s_addr = ipv4_hdr->src_addr;
-    dst_in_addr_.s_addr = ipv4_hdr->dst_addr;
+    ipv4_addr_.src_in_addr.s_addr = ipv4_hdr->src_addr;
+    ipv4_addr_.dst_in_addr.s_addr = ipv4_hdr->dst_addr;
 
     this_layer_length = offset;
     this_layer_type = TUNNEL_TYPE_G_VXLAN;
@@ -243,7 +243,7 @@ int TunInnerEther::PacketParse(const char * pkt, unsigned int len)
     
 l3:
     if (proto == ntohs(ETHER_TYPE_IPv4)) next_layer_type = TUNNEL_TYPE_IPV4;
-    else if (proto == ntohs(ETHER_TYPE_IPv4)) next_layer_type = TUNNEL_TYPE_IPV6;
+    else if (proto == ntohs(ETHER_TYPE_IPv6)) next_layer_type = TUNNEL_TYPE_IPV6;
 
     this_layer_type = TUNNEL_TYPE_ETHER;
     this_layer_length = offset;
@@ -296,8 +296,8 @@ int TunInnerPPP::PacketParse(const char * pkt, unsigned int pkt_len)
     this_layer_length = PPP_HDRLEN;
     TUNNAT_THREAD_STAT_ADD(TUNNAT_STAT_INNER_PPP_INPUT, 1);
     return 0;
-}

-

+}
+
 int TunnelContainer::PacketParse(const char * pkt, unsigned int pkt_len, 
     tunnel_type tunnel_type)
 {
@@ -454,8 +454,8 @@ void TunnelContainer::ReverseAddress()
 int TunInnerIPv4::PacketParse(const char * pkt, unsigned int pkt_len)
 {
     struct ipv4_hdr * ipv4_hdr = (struct ipv4_hdr *)pkt;
-    src_in_addr_.s_addr = ipv4_hdr->src_addr;
-    dst_in_addr_.s_addr = ipv4_hdr->dst_addr;
+    ipv4_addr.src_in_addr.s_addr = ipv4_hdr->src_addr;
+    ipv4_addr.dst_in_addr.s_addr = ipv4_hdr->dst_addr;
 
     this_layer_type = TUNNEL_TYPE_IPV4;
     next_layer_type = TUNNEL_TYPE_UNKNOWN;
@@ -465,14 +465,17 @@ int TunInnerIPv4::PacketParse(const char * pkt, unsigned int pkt_len)
 
 int TunInnerIPv6::PacketParse(const char * pkt, unsigned int pkt_len)
 {
-    return 0;
-}
+    struct ipv6_hdr * ipv6_hdr = (struct ipv6_hdr *)pkt;
+    memcpy(&ipv6_addr.src_in6_addr, ipv6_hdr->src_addr, sizeof(struct in6_addr));
+    memcpy(&ipv6_addr.dst_in6_addr, ipv6_hdr->dst_addr, sizeof(struct in6_addr));
 
-int TunInnerIPv6::GetAddressInfo(AddressInfo & addr_info)
-{
+    this_layer_type = TUNNEL_TYPE_IPV6;
+    next_layer_type = TUNNEL_TYPE_UNKNOWN;
+    this_layer_length = sizeof(struct ipv6_hdr);
     return 0;
 }
 
+
 int TunInnerHDLC::PacketParse(const char * pkt, unsigned int pkt_len)
 {
     uint16_t hdlc_proto = *(const uint16_t *)(pkt + 2);
@@ -498,4 +501,4 @@ int TunInnerHDLC::PacketParse(const char * pkt, unsigned int pkt_len)
 
     TUNNAT_THREAD_STAT_ADD(TUNNAT_STAT_INNER_HDLC_INPUT, 1);
     return 0;
-}
\ No newline at end of file
+}
diff --git a/tunnat/test/TestSession.cc b/tunnat/test/TestSession.cc
index 55e2938..81fc21a 100644
--- a/tunnat/test/TestSession.cc
+++ b/tunnat/test/TestSession.cc
@@ -26,10 +26,22 @@ public:
     }
 };
 
-int SessionKeyGenerate(SessionKey & key)
+int SessionKeyGenerate(SessionKey & key,enum key_type type)
 {
-    key.s_in_addr.s_addr = rand();
-    key.d_in_addr.s_addr = rand();
+	key.type=type;
+	switch(type)
+	{
+	case KEY_TYPE_IPV4:
+		key.ipv4_key.s_in_addr.s_addr = rand();
+    	key.ipv4_key.d_in_addr.s_addr = rand();
+		break;
+	case KEY_TYPE_IPV6:
+		break;
+	default:
+		assert(0);
+		break;
+	}
+   
     return 0;
 }
 
@@ -49,7 +61,7 @@ TEST(TunnatSession, TunnatSessionRandomAddQuery)
 
     for (int i = 0; i < rd_keys; i++)
     {
-        SessionKeyGenerate(__test_keys);
+        SessionKeyGenerate(__test_keys,KEY_TYPE_IPV4);
         ss_table->Add(__test_keys, __test_entry);
         vec_test_keys.push_back(__test_keys);
     }