gfwleak/tango-tsg-service-chaining-engine
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf: rename addr_tuple4 to four_tuple

Browse Source
This commit is contained in:
luwenpeng
2023-11-08 10:20:27 +08:00
parent 3627addb85
commit 8fe574633b
13 changed files with 177 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
common/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
add_library(common src/addr_tuple4.cpp src/session_table.cpp src/data_packet.cpp src/control_packet.cpp src/bfd.cpp src/utils.cpp src/g_vxlan.cpp src/log.cpp src/timestamp.cpp src/mpack.cpp)
add_library(common src/four_tuple.cpp src/session_table.cpp src/data_packet.cpp src/control_packet.cpp src/bfd.cpp src/utils.cpp src/g_vxlan.cpp src/log.cpp src/timestamp.cpp src/mpack.cpp)
target_link_libraries(common PUBLIC cjson)
target_link_libraries(common PUBLIC MESA_handle_logger)

8
common/include/data_packet.h
View File

@@ -80,13 +80,13 @@ const void *data_packet_parse(struct data_packet *handler, const void *data, siz
// return 0 : success
// return -1 : error
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr);
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr);
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr);
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr);
// return 0 : success
// return -1 : error
int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr);
int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr);
int data_packet_get_innermost_address(struct data_packet *handler, struct four_tuple *addr);
int data_packet_get_outermost_address(struct data_packet *handler, struct four_tuple *addr);
uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e);

28
common/include/addr_tuple4.h → common/include/four_tuple.h
View File

@@ -1,5 +1,5 @@
#ifndef _ADDR_TUPLE4_H
#define _ADDR_TUPLE4_H
#ifndef _FOUR_TUPLE_H
#define _FOUR_TUPLE_H
#ifdef __cpluscplus
extern "C"
@@ -8,10 +8,10 @@ extern "C"
#include <netinet/in.h>
enum addr_tuple4_type
enum addr_type
{
ADDR_TUPLE4_TYPE_V4,
ADDR_TUPLE4_TYPE_V6,
ADDR_TYPE_V4,
ADDR_TYPE_V6,
};
struct addr_v4
@@ -26,9 +26,9 @@ struct addr_v6
struct in6_addr dst_addr; /* network order */
};
struct addr_tuple4
struct four_tuple
{
enum addr_tuple4_type addr_type;
enum addr_type addr_type;
in_port_t src_port; /* network order */
in_port_t dst_port; /* network order */
union
@@ -39,26 +39,26 @@ struct addr_tuple4
};
#define INIT_ADDR_V4(name, src_addr_str, src_port_num, dst_addr_str, dst_port_num) \
struct addr_tuple4 name; \
struct four_tuple name; \
memset(&name, 0, sizeof(name)); \
(name).addr_type = ADDR_TUPLE4_TYPE_V4; \
(name).addr_type = ADDR_TYPE_V4; \
(name).src_port = htons((src_port_num)); \
(name).dst_port = htons((dst_port_num)); \
inet_pton(AF_INET, (src_addr_str), &(name).addr_v4.src_addr); \
inet_pton(AF_INET, (dst_addr_str), &(name).addr_v4.dst_addr);
#define INIT_ADDR_V6(name, src_addr_str, src_port_num, dst_addr_str, dst_port_num) \
struct addr_tuple4 name; \
struct four_tuple name; \
memset(&name, 0, sizeof(name)); \
(name).addr_type = ADDR_TUPLE4_TYPE_V6; \
(name).addr_type = ADDR_TYPE_V6; \
(name).src_port = htons((src_port_num)); \
(name).dst_port = htons((dst_port_num)); \
inet_pton(AF_INET6, (src_addr_str), &(name).addr_v6.src_addr); \
inet_pton(AF_INET6, (dst_addr_str), &(name).addr_v6.dst_addr);
void addr_tuple4_copy(struct addr_tuple4 *dst, struct addr_tuple4 *src);
char *addr_tuple4_to_str(const struct addr_tuple4 *addr);
void addr_tuple4_reverse(const struct addr_tuple4 *orin, struct addr_tuple4 *out);
void four_tuple_copy(struct four_tuple *dst, struct four_tuple *src);
char *four_tuple_to_string(const struct four_tuple *addr);
void four_tuple_reverse(const struct four_tuple *orin, struct four_tuple *out);
#ifdef __cpluscplus
}

10
common/include/session_table.h
View File

@@ -10,7 +10,7 @@ extern "C"
#include <sys/types.h>
#include "uthash.h"
#include "addr_tuple4.h"
#include "four_tuple.h"
// Note: session_addr must be initialized by memset(0) before use !!!
@@ -19,7 +19,7 @@ typedef void fn_free_cb(void *args);
struct session_node
{
uint64_t session_id; /* first key */
struct addr_tuple4 session_addr; /* second key */
struct four_tuple session_addr; /* second key */
void *value;
fn_free_cb *value_free_cb;
@@ -39,17 +39,17 @@ uint64_t session_table_count(struct session_table *table);
// value : shallow copy (malloc by user, free by value_free_cb)
// return 0 : suceess
// return -1 : key exists
int session_table_insert(struct session_table *table, uint64_t session_id, const struct addr_tuple4 *session_addr, void *value, const fn_free_cb *value_free_cb);
int session_table_insert(struct session_table *table, uint64_t session_id, const struct four_tuple *session_addr, void *value, const fn_free_cb *value_free_cb);
// return 0 : success
// return -1 : key not exists
int session_table_delete_by_id(struct session_table *table, uint64_t session_id);
int session_table_delete_by_addr(struct session_table *table, const struct addr_tuple4 *session_addr);
int session_table_delete_by_addr(struct session_table *table, const struct four_tuple *session_addr);
// return NULL : key not exists
// return UnNULL : success
struct session_node *session_table_search_by_id(struct session_table *table, uint64_t session_id);
struct session_node *session_table_search_by_addr(struct session_table *table, const struct addr_tuple4 *session_addr);
struct session_node *session_table_search_by_addr(struct session_table *table, const struct four_tuple *session_addr);
#ifdef __cpluscplus
}

30
common/src/data_packet.cpp
View File

@@ -13,7 +13,7 @@
#include "log.h"
#include "utils.h"
#include "uthash.h"
#include "addr_tuple4.h"
#include "four_tuple.h"
#include "data_packet.h"
/******************************************************************************
@@ -65,7 +65,7 @@ static int data_packet_push_layer(struct data_packet *handler, enum layer_type t
static const char *ldbc_method_to_string(enum ldbc_method ldbc_method);
// parser utils
static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct addr_tuple4 *addr);
static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr);
static const char *layer_type2str(enum layer_type this_type);
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
@@ -101,7 +101,7 @@ const void *data_packet_parse(struct data_packet *handler, const void *data, siz
// return 0 : success
// return -1 : error
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
@@ -156,7 +156,7 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tu
// return 0 : success
// return -1 : error
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
@@ -211,7 +211,7 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tu
// return 0 : success
// return -1 : error
int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
int data_packet_get_innermost_address(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
@@ -236,7 +236,7 @@ int data_packet_get_innermost_address(struct data_packet *handler, struct addr_t
// return 0 : success
// return -1 : error
int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
int data_packet_get_outermost_address(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
@@ -271,8 +271,8 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth
const char *outer_src_addr = NULL;
const char *outer_dst_addr = NULL;
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
@@ -291,7 +291,7 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth
return hash_value;
}
if (inner_addr.addr_type == ADDR_TUPLE4_TYPE_V4)
if (inner_addr.addr_type == ADDR_TYPE_V4)
{
inner_src_addr = (const char *)&(inner_addr.addr_v4.src_addr);
inner_dst_addr = (const char *)&(inner_addr.addr_v4.dst_addr);
@@ -304,7 +304,7 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth
inner_addr_len = sizeof(inner_addr.addr_v6.dst_addr);
}
if (outer_addr.addr_type == ADDR_TUPLE4_TYPE_V4)
if (outer_addr.addr_type == ADDR_TYPE_V4)
{
outer_src_addr = (const char *)&(outer_addr.addr_v4.src_addr);
outer_dst_addr = (const char *)&(outer_addr.addr_v4.dst_addr);
@@ -377,8 +377,8 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth
return hash_value;
}
char *inner_addr_str = addr_tuple4_to_str(&inner_addr);
char *outer_addr_str = addr_tuple4_to_str(&outer_addr);
char *inner_addr_str = four_tuple_to_string(&inner_addr);
char *outer_addr_str = four_tuple_to_string(&outer_addr);
LOG_DEBUG("%s: trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_TAG_RAWPKT, handler->trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
free(inner_addr_str);
@@ -428,7 +428,7 @@ static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
}
}
static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct addr_tuple4 *addr)
static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr)
{
const struct tcphdr *tcp_hdr = NULL;
const struct udp_hdr *udp_hdr = NULL;
@@ -449,13 +449,13 @@ static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct
break;
case LAYER_TYPE_IPV4:
ipv4_hdr = (const struct ip *)data;
addr->addr_type = ADDR_TUPLE4_TYPE_V4;
addr->addr_type = ADDR_TYPE_V4;
addr->addr_v4.src_addr = ipv4_hdr->ip_src;
addr->addr_v4.dst_addr = ipv4_hdr->ip_dst;
break;
case LAYER_TYPE_IPV6:
ipv6_hdr = (const struct ip6_hdr *)data;
addr->addr_type = ADDR_TUPLE4_TYPE_V6;
addr->addr_type = ADDR_TYPE_V6;
memcpy(&addr->addr_v6.src_addr, &ipv6_hdr->ip6_src, sizeof(addr->addr_v6.src_addr));
memcpy(&addr->addr_v6.dst_addr, &ipv6_hdr->ip6_dst, sizeof(addr->addr_v6.dst_addr));
break;

24
common/src/addr_tuple4.cpp → common/src/four_tuple.cpp
View File

@@ -2,15 +2,15 @@
#include <string.h>
#include <arpa/inet.h>
#include "addr_tuple4.h"
#include "four_tuple.h"
void addr_tuple4_copy(struct addr_tuple4 *dst, struct addr_tuple4 *src)
void four_tuple_copy(struct four_tuple *dst, struct four_tuple *src)
{
dst->addr_type = src->addr_type;
dst->src_port = src->src_port;
dst->dst_port = src->dst_port;
if (src->addr_type == ADDR_TUPLE4_TYPE_V4)
if (src->addr_type == ADDR_TYPE_V4)
{
memcpy(&(dst->addr_v4.src_addr), &(src->addr_v4.src_addr), sizeof(struct in_addr));
memcpy(&(dst->addr_v4.dst_addr), &(src->addr_v4.dst_addr), sizeof(struct in_addr));
@@ -22,11 +22,11 @@ void addr_tuple4_copy(struct addr_tuple4 *dst, struct addr_tuple4 *src)
}
}
char *addr_tuple4_to_str(const struct addr_tuple4 *addr)
char *four_tuple_to_string(const struct four_tuple *addr)
{
char *str_ret = NULL;
if (addr->addr_type == ADDR_TUPLE4_TYPE_V4)
if (addr->addr_type == ADDR_TYPE_V4)
{
char src_addr[INET_ADDRSTRLEN] = {0};
char dst_addr[INET_ADDRSTRLEN] = {0};
@@ -37,7 +37,7 @@ char *addr_tuple4_to_str(const struct addr_tuple4 *addr)
asprintf(&str_ret, "%s %u %s %u", src_addr, src_port, dst_addr, dst_port);
}
if (addr->addr_type == ADDR_TUPLE4_TYPE_V6)
if (addr->addr_type == ADDR_TYPE_V6)
{
char src_addr[INET6_ADDRSTRLEN] = {0};
char dst_addr[INET6_ADDRSTRLEN] = {0};
@@ -51,22 +51,22 @@ char *addr_tuple4_to_str(const struct addr_tuple4 *addr)
return str_ret;
}
void addr_tuple4_reverse(const struct addr_tuple4 *orin, struct addr_tuple4 *out)
void four_tuple_reverse(const struct four_tuple *orin, struct four_tuple *out)
{
memset(out, 0, sizeof(struct addr_tuple4));
memset(out, 0, sizeof(struct four_tuple));
if (orin->addr_type == ADDR_TUPLE4_TYPE_V4)
if (orin->addr_type == ADDR_TYPE_V4)
{
out->addr_type = ADDR_TUPLE4_TYPE_V4;
out->addr_type = ADDR_TYPE_V4;
out->addr_v4.src_addr = orin->addr_v4.dst_addr;
out->addr_v4.dst_addr = orin->addr_v4.src_addr;
out->src_port = orin->dst_port;
out->dst_port = orin->src_port;
}
if (orin->addr_type == ADDR_TUPLE4_TYPE_V6)
if (orin->addr_type == ADDR_TYPE_V6)
{
out->addr_type = ADDR_TUPLE4_TYPE_V6;
out->addr_type = ADDR_TYPE_V6;
out->addr_v6.src_addr = orin->addr_v6.dst_addr;
out->addr_v6.dst_addr = orin->addr_v6.src_addr;
out->src_port = orin->dst_port;

24
common/src/session_table.cpp
View File

@@ -84,7 +84,7 @@ uint64_t session_table_count(struct session_table *table)
// session_addr : deep copy
// value : shallow copy (malloc by user, free by value_free_cb)
int session_table_insert(struct session_table *table, uint64_t session_id, const struct addr_tuple4 *session_addr, void *value, const fn_free_cb *value_free_cb)
int session_table_insert(struct session_table *table, uint64_t session_id, const struct four_tuple *session_addr, void *value, const fn_free_cb *value_free_cb)
{
struct session_node *temp = NULL;
HASH_FIND(hh1, table->root_by_id, &session_id, sizeof(session_id), temp);
@@ -97,7 +97,7 @@ int session_table_insert(struct session_table *table, uint64_t session_id, const
assert(temp);
temp->session_id = session_id;
memcpy(&temp->session_addr, session_addr, sizeof(struct addr_tuple4));
memcpy(&temp->session_addr, session_addr, sizeof(struct four_tuple));
temp->value = value;
temp->value_free_cb = value_free_cb;
@@ -135,15 +135,15 @@ int session_table_delete_by_id(struct session_table *table, uint64_t session_id)
return 0;
}
int session_table_delete_by_addr(struct session_table *table, const struct addr_tuple4 *session_addr)
int session_table_delete_by_addr(struct session_table *table, const struct four_tuple *session_addr)
{
struct session_node *temp = NULL;
HASH_FIND(hh2, table->root_by_addr, session_addr, sizeof(struct addr_tuple4), temp);
HASH_FIND(hh2, table->root_by_addr, session_addr, sizeof(struct four_tuple), temp);
if (!temp)
{
struct addr_tuple4 reverse_addr;
addr_tuple4_reverse(session_addr, &reverse_addr);
HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct addr_tuple4), temp);
struct four_tuple reverse_addr;
four_tuple_reverse(session_addr, &reverse_addr);
HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct four_tuple), temp);
if (!temp)
{
return -1;
@@ -179,15 +179,15 @@ struct session_node *session_table_search_by_id(struct session_table *table, uin
return temp;
}
struct session_node *session_table_search_by_addr(struct session_table *table, const struct addr_tuple4 *session_addr)
struct session_node *session_table_search_by_addr(struct session_table *table, const struct four_tuple *session_addr)
{
struct session_node *temp = NULL;
HASH_FIND(hh2, table->root_by_addr, session_addr, sizeof(struct addr_tuple4), temp);
HASH_FIND(hh2, table->root_by_addr, session_addr, sizeof(struct four_tuple), temp);
if (!temp)
{
struct addr_tuple4 reverse_addr;
addr_tuple4_reverse(session_addr, &reverse_addr);
HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct addr_tuple4), temp);
struct four_tuple reverse_addr;
four_tuple_reverse(session_addr, &reverse_addr);
HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct four_tuple), temp);
if (!temp)
{
return NULL;

10
common/test/CMakeLists.txt
View File

@@ -1,10 +1,10 @@
###############################################################################
# gtest_addr_tuple4
# gtest_four_tuple
###############################################################################
add_executable(gtest_addr_tuple4 gtest_addr_tuple4.cpp)
target_include_directories(gtest_addr_tuple4 PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_addr_tuple4 common gtest)
add_executable(gtest_four_tuple gtest_four_tuple.cpp)
target_include_directories(gtest_four_tuple PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_four_tuple common gtest)
###############################################################################
# gtest_session_table
@@ -51,7 +51,7 @@ target_link_libraries(gtest_health_check_table common gtest platform)
###############################################################################
include(GoogleTest)
gtest_discover_tests(gtest_addr_tuple4)
gtest_discover_tests(gtest_four_tuple)
gtest_discover_tests(gtest_session_table)
gtest_discover_tests(gtest_data_packet)
gtest_discover_tests(gtest_control_packet)

138
common/test/gtest_data_packet.cpp
View File

@@ -2,7 +2,7 @@
#include <arpa/inet.h>
#include "data_packet.h"
#include "addr_tuple4.h"
#include "four_tuple.h"
/******************************************************************************
* Pcap file: 1-ETH_VLAN_VLAN_IP4_IP4_UDP.pcap
@@ -83,8 +83,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data1 == 70);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -92,8 +92,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
EXPECT_STREQ(outer_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
free(inner_addr_str);
@@ -103,8 +103,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.10.100.25 0 10.10.101.2 0");
EXPECT_STREQ(outer_addr_str, "69.67.35.146 0 41.202.46.110 0");
free(inner_addr_str);
@@ -213,8 +213,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data2 == 94);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -222,8 +222,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "1.1.1.1 57639 2.2.2.2 22");
EXPECT_STREQ(outer_addr_str, "1.1.1.1 57639 2.2.2.2 22");
free(inner_addr_str);
@@ -233,8 +233,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "1.1.1.1 0 2.2.2.2 0");
EXPECT_STREQ(outer_addr_str, "2001::192:168:40:134 0 2001::192:168:40:133 0");
free(inner_addr_str);
@@ -338,8 +338,8 @@ TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data3 == 126);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -347,8 +347,8 @@ TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "8.8.8.8 53 172.16.44.3 9879");
EXPECT_STREQ(outer_addr_str, "8.8.8.8 53 172.16.44.3 9879");
free(inner_addr_str);
@@ -358,8 +358,8 @@ TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "8.8.8.8 0 172.16.44.3 0");
EXPECT_STREQ(outer_addr_str, "2607:fcd0:100:2300::b108:2a6b 0 2402:f000:1:8e01::5555 0");
free(inner_addr_str);
@@ -438,8 +438,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data4 == 106);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -447,8 +447,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
EXPECT_STREQ(outer_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
free(inner_addr_str);
@@ -458,8 +458,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 0 2600:140e:6::1702:1058 0");
EXPECT_STREQ(outer_addr_str, "210.77.88.163 0 59.66.4.50 0");
free(inner_addr_str);
@@ -523,8 +523,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data5 == 102);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -532,8 +532,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000");
EXPECT_STREQ(outer_addr_str, "dead::beef 30000 cafe::babe 13000");
free(inner_addr_str);
@@ -543,8 +543,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 0 cafe::babe 0");
EXPECT_STREQ(outer_addr_str, "2001:4f8:4:7:2e0:81ff:fe52:ffff 0 2001:4f8:4:7:2e0:81ff:fe52:9a6b 0");
free(inner_addr_str);
@@ -615,8 +615,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data6 == 70);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -624,8 +624,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "119.40.37.65 61853 123.125.29.250 80");
EXPECT_STREQ(outer_addr_str, "119.40.37.65 61853 123.125.29.250 80");
free(inner_addr_str);
@@ -635,8 +635,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "119.40.37.65 0 123.125.29.250 0");
EXPECT_STREQ(outer_addr_str, "119.40.37.65 0 123.125.29.250 0");
free(inner_addr_str);
@@ -712,8 +712,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data7 == 66);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -721,8 +721,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.31.0.1 11001 10.34.0.1 23");
EXPECT_STREQ(outer_addr_str, "10.31.0.1 11001 10.34.0.1 23");
free(inner_addr_str);
@@ -732,8 +732,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.31.0.1 0 10.34.0.1 0");
EXPECT_STREQ(outer_addr_str, "10.31.0.1 0 10.34.0.1 0");
free(inner_addr_str);
@@ -814,8 +814,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data8 == 78);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -823,8 +823,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "100.65.55.0 34532 91.185.14.33 443");
EXPECT_STREQ(outer_addr_str, "100.65.55.0 34532 91.185.14.33 443");
free(inner_addr_str);
@@ -834,8 +834,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "100.65.55.0 0 91.185.14.33 0");
EXPECT_STREQ(outer_addr_str, "100.65.55.0 0 91.185.14.33 0");
free(inner_addr_str);
@@ -975,8 +975,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data9 == 130);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -984,8 +984,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 443 2409:8934:5082:2100:ecad:e0e4:530a:c269 46582");
EXPECT_STREQ(outer_addr_str, "2409:8034:4040:5300::105 2152 2409:8034:4025::60:61 2152");
free(inner_addr_str);
@@ -995,8 +995,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 0 2409:8934:5082:2100:ecad:e0e4:530a:c269 0");
EXPECT_STREQ(outer_addr_str, "2409:8034:4040:5300::105 0 2409:8034:4025::60:61 0");
free(inner_addr_str);
@@ -1143,8 +1143,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data10 == 122);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -1152,8 +1152,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.49.115.138 50081 121.196.250.66 443");
EXPECT_STREQ(outer_addr_str, "2409:8034:4025::50:a31 2152 2409:8034:4040:5301::204 2152");
free(inner_addr_str);
@@ -1163,8 +1163,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.49.115.138 0 121.196.250.66 0");
EXPECT_STREQ(outer_addr_str, "2409:8034:4025::50:a31 0 2409:8034:4040:5301::204 0");
free(inner_addr_str);
@@ -1253,8 +1253,8 @@ TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data11 == 92);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
char *inner_addr_str = NULL;
char *outer_addr_str = NULL;
@@ -1262,8 +1262,8 @@ TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "192.168.11.193 65290 114.114.114.114 53");
EXPECT_STREQ(outer_addr_str, "10.1.1.1 50709 192.168.1.10 4789");
free(inner_addr_str);
@@ -1273,8 +1273,8 @@ TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "192.168.11.193 0 114.114.114.114 0");
EXPECT_STREQ(outer_addr_str, "10.1.1.1 0 192.168.1.10 0");
free(inner_addr_str);
@@ -1325,8 +1325,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data12 == 40);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
struct four_tuple inner_addr;
struct four_tuple outer_addr;
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == -1);

18
common/test/gtest_addr_tuple4.cpp → common/test/gtest_four_tuple.cpp
View File

@@ -1,22 +1,22 @@
#include <gtest/gtest.h>
#include <arpa/inet.h>
#include "addr_tuple4.h"
#include "four_tuple.h"
TEST(ADDR_TUPLE4, IPV4)
{
char *ret_str = NULL;
struct addr_tuple4 reve_addr;
struct four_tuple reve_addr;
INIT_ADDR_V4(orin_addr, "1.2.3.4", 12345, "4.3.2.1", 23456)
addr_tuple4_reverse(&orin_addr, &reve_addr);
four_tuple_reverse(&orin_addr, &reve_addr);
ret_str = addr_tuple4_to_str(&orin_addr);
ret_str = four_tuple_to_string(&orin_addr);
EXPECT_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "1.2.3.4 12345 4.3.2.1 23456");
free(ret_str);
ret_str = addr_tuple4_to_str(&reve_addr);
ret_str = four_tuple_to_string(&reve_addr);
EXPECT_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "4.3.2.1 23456 1.2.3.4 12345");
free(ret_str);
@@ -25,17 +25,17 @@ TEST(ADDR_TUPLE4, IPV4)
TEST(ADDR_TUPLE4, IPV6)
{
char *ret_str = NULL;
struct addr_tuple4 reve_addr;
struct four_tuple reve_addr;
INIT_ADDR_V6(orin_addr, "1:2::3", 12345, "a:b::c", 23456);
addr_tuple4_reverse(&orin_addr, &reve_addr);
four_tuple_reverse(&orin_addr, &reve_addr);
ret_str = addr_tuple4_to_str(&orin_addr);
ret_str = four_tuple_to_string(&orin_addr);
EXPECT_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "1:2::3 12345 a:b::c 23456");
free(ret_str);
ret_str = addr_tuple4_to_str(&reve_addr);
ret_str = four_tuple_to_string(&reve_addr);
EXPECT_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "a:b::c 23456 1:2::3 12345");
free(ret_str);

32
common/test/gtest_session_table.cpp
View File

@@ -101,10 +101,10 @@ TEST(STREAM_TABLE, SEARCH_BY_REVERSE_ADDR)
char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321);
INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse;
struct addr_tuple4 addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse);
struct four_tuple addr1_reverse;
struct four_tuple addr2_reverse;
four_tuple_reverse(&addr1, &addr1_reverse);
four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0);
@@ -134,10 +134,10 @@ TEST(STREAM_TABLE, DELETE_BY_ID)
char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321);
INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse;
struct addr_tuple4 addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse);
struct four_tuple addr1_reverse;
struct four_tuple addr2_reverse;
four_tuple_reverse(&addr1, &addr1_reverse);
four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0);
@@ -171,10 +171,10 @@ TEST(STREAM_TABLE, DELETE_BY_ADDR)
char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321);
INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse;
struct addr_tuple4 addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse);
struct four_tuple addr1_reverse;
struct four_tuple addr2_reverse;
four_tuple_reverse(&addr1, &addr1_reverse);
four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0);
@@ -208,10 +208,10 @@ TEST(STREAM_TABLE, DELETE_BY_REVERSE_ADDR)
char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321);
INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse;
struct addr_tuple4 addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse);
struct four_tuple addr1_reverse;
struct four_tuple addr2_reverse;
four_tuple_reverse(&addr1, &addr1_reverse);
four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0);

2
platform/include/sce.h
View File

@@ -75,7 +75,7 @@ struct session_ctx
uint64_t session_id;
char *session_addr;
struct addr_tuple4 inner_tuple4;
struct four_tuple inner_tuple4;
struct mutable_array rule_ids;
struct metadata *decrypted_meta_i2e;

28
platform/src/packet_io.cpp
View File

@@ -347,17 +347,17 @@ static int is_uplink_keepalive_packet(marsio_buff_t *rx_buff)
// return NULL
static struct session_ctx *data_packet_search_session(struct session_table *table, const char *raw_data, int raw_len, uint64_t session_id)
{
struct addr_tuple4 inner_addr;
struct addr_tuple4 reverse_addr;
struct four_tuple inner_addr;
struct four_tuple reverse_addr;
struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4));
memset(&reverse_addr, 0, sizeof(struct addr_tuple4));
memset(&inner_addr, 0, sizeof(struct four_tuple));
memset(&reverse_addr, 0, sizeof(struct four_tuple));
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
addr_tuple4_reverse(&inner_addr, &reverse_addr);
four_tuple_reverse(&inner_addr, &reverse_addr);
struct session_node *node = session_table_search_by_id(table, session_id);
if (node == NULL)
@@ -366,9 +366,9 @@ static struct session_ctx *data_packet_search_session(struct session_table *tabl
}
struct session_ctx *session_ctx = (struct session_ctx *)node->value;
if (memcmp(&session_ctx->inner_tuple4, &inner_addr, sizeof(struct addr_tuple4)) != 0 && memcmp(&session_ctx->inner_tuple4, &reverse_addr, sizeof(struct addr_tuple4)) != 0)
if (memcmp(&session_ctx->inner_tuple4, &inner_addr, sizeof(struct four_tuple)) != 0 && memcmp(&session_ctx->inner_tuple4, &reverse_addr, sizeof(struct four_tuple)) != 0)
{
char *addr_str = addr_tuple4_to_str(&inner_addr);
char *addr_str = four_tuple_to_string(&inner_addr);
LOG_ERROR("%s: unexpected raw packet, session %lu expected address tuple4 is %s, but current packet's address tuple4 is %s, bypass !!!", LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr, addr_str);
free(addr_str);
return NULL;
@@ -381,10 +381,10 @@ static struct session_ctx *data_packet_search_session(struct session_table *tabl
// return NULL
static struct session_ctx *inject_packet_search_session(struct session_table *table, const char *raw_data, int raw_len)
{
struct addr_tuple4 inner_addr;
struct four_tuple inner_addr;
struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4));
memset(&inner_addr, 0, sizeof(struct four_tuple));
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
@@ -393,7 +393,7 @@ static struct session_ctx *inject_packet_search_session(struct session_table *ta
struct session_node *node = session_table_search_by_addr(table, &inner_addr);
if (node == NULL)
{
char *addr_str = addr_tuple4_to_str(&inner_addr);
char *addr_str = four_tuple_to_string(&inner_addr);
LOG_ERROR("%s: unexpected inject packet, unable to find session %s from session table, drop !!!", LOG_TAG_PKTIO, addr_str);
free(addr_str);
return NULL;
@@ -914,21 +914,21 @@ static void handle_session_opening(struct metadata *meta, struct control_packet
#endif
struct data_packet data_pkt;
struct addr_tuple4 inner_tuple4;
struct four_tuple inner_tuple4;
const void *payload = data_packet_parse(&data_pkt, (const void *)meta->raw_data, meta->raw_len, meta->session_id);
data_packet_get_innermost_tuple4(&data_pkt, &inner_tuple4);
uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset)
{
char *addr_str = addr_tuple4_to_str(&inner_tuple4);
char *addr_str = four_tuple_to_string(&inner_tuple4);
LOG_ERROR("%s: incorrect dataoffset %d in the control zone of session %lu %s, the expect value is %d", LOG_TAG_PKTIO, meta->l7offset, meta->session_id, addr_str, real_offset);
free(addr_str);
}
struct session_ctx *session_ctx = session_ctx_new();
session_ctx->session_id = meta->session_id;
session_ctx->session_addr = addr_tuple4_to_str(&inner_tuple4);
addr_tuple4_copy(&session_ctx->inner_tuple4, &inner_tuple4);
session_ctx->session_addr = four_tuple_to_string(&inner_tuple4);
four_tuple_copy(&session_ctx->inner_tuple4, &inner_tuple4);
metadata_deep_copy(session_ctx->ctrl_meta, meta);
session_ctx->chainings.chaining_raw = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);
session_ctx->chainings.chaining_decrypted = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);