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 cjson)
target_link_libraries(common PUBLIC MESA_handle_logger) 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 0 : success
// return -1 : error // 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);
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);
// return 0 : success // return 0 : success
// return -1 : error // 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);
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);
uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e); 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 #ifndef _FOUR_TUPLE_H
#define _ADDR_TUPLE4_H #define _FOUR_TUPLE_H
#ifdef __cpluscplus #ifdef __cpluscplus
extern "C" extern "C"
@@ -8,10 +8,10 @@ extern "C"
#include <netinet/in.h> #include <netinet/in.h>
enum addr_tuple4_type enum addr_type
{ {
ADDR_TUPLE4_TYPE_V4, ADDR_TYPE_V4,
ADDR_TUPLE4_TYPE_V6, ADDR_TYPE_V6,
}; };
struct addr_v4 struct addr_v4
@@ -26,9 +26,9 @@ struct addr_v6
struct in6_addr dst_addr; /* network order */ 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 src_port; /* network order */
in_port_t dst_port; /* network order */ in_port_t dst_port; /* network order */
union 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) \ #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)); \ 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).src_port = htons((src_port_num)); \
(name).dst_port = htons((dst_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, (src_addr_str), &(name).addr_v4.src_addr); \
inet_pton(AF_INET, (dst_addr_str), &(name).addr_v4.dst_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) \ #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)); \ 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).src_port = htons((src_port_num)); \
(name).dst_port = htons((dst_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, (src_addr_str), &(name).addr_v6.src_addr); \
inet_pton(AF_INET6, (dst_addr_str), &(name).addr_v6.dst_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); void four_tuple_copy(struct four_tuple *dst, struct four_tuple *src);
char *addr_tuple4_to_str(const struct addr_tuple4 *addr); char *four_tuple_to_string(const struct four_tuple *addr);
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);
#ifdef __cpluscplus #ifdef __cpluscplus
} }

10
common/include/session_table.h
View File

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

30
common/src/data_packet.cpp
View File

@@ -13,7 +13,7 @@
#include "log.h" #include "log.h"
#include "utils.h" #include "utils.h"
#include "uthash.h" #include "uthash.h"
#include "addr_tuple4.h" #include "four_tuple.h"
#include "data_packet.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); static const char *ldbc_method_to_string(enum ldbc_method ldbc_method);
// parser utils // 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 const char *layer_type2str(enum layer_type this_type);
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph); 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 0 : success
// return -1 : error // 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 *l3_layer_data = NULL;
const char *l4_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 0 : success
// return -1 : error // 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 *l3_layer_data = NULL;
const char *l4_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 0 : success
// return -1 : error // 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; const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results; 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 0 : success
// return -1 : error // 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; const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results; 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_src_addr = NULL;
const char *outer_dst_addr = NULL; const char *outer_dst_addr = NULL;
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
memset(&inner_addr, 0, sizeof(inner_addr)); memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_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; 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_src_addr = (const char *)&(inner_addr.addr_v4.src_addr);
inner_dst_addr = (const char *)&(inner_addr.addr_v4.dst_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); 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_src_addr = (const char *)&(outer_addr.addr_v4.src_addr);
outer_dst_addr = (const char *)&(outer_addr.addr_v4.dst_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; return hash_value;
} }
char *inner_addr_str = addr_tuple4_to_str(&inner_addr); char *inner_addr_str = four_tuple_to_string(&inner_addr);
char *outer_addr_str = addr_tuple4_to_str(&outer_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_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); 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); 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 tcphdr *tcp_hdr = NULL;
const struct udp_hdr *udp_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; break;
case LAYER_TYPE_IPV4: case LAYER_TYPE_IPV4:
ipv4_hdr = (const struct ip *)data; 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.src_addr = ipv4_hdr->ip_src;
addr->addr_v4.dst_addr = ipv4_hdr->ip_dst; addr->addr_v4.dst_addr = ipv4_hdr->ip_dst;
break; break;
case LAYER_TYPE_IPV6: case LAYER_TYPE_IPV6:
ipv6_hdr = (const struct ip6_hdr *)data; 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.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)); memcpy(&addr->addr_v6.dst_addr, &ipv6_hdr->ip6_dst, sizeof(addr->addr_v6.dst_addr));
break; break;

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

@@ -2,15 +2,15 @@
#include <string.h> #include <string.h>
#include <arpa/inet.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->addr_type = src->addr_type;
dst->src_port = src->src_port; dst->src_port = src->src_port;
dst->dst_port = src->dst_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.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)); 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; 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 src_addr[INET_ADDRSTRLEN] = {0};
char dst_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); 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 src_addr[INET6_ADDRSTRLEN] = {0};
char dst_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; 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.src_addr = orin->addr_v4.dst_addr;
out->addr_v4.dst_addr = orin->addr_v4.src_addr; out->addr_v4.dst_addr = orin->addr_v4.src_addr;
out->src_port = orin->dst_port; out->src_port = orin->dst_port;
out->dst_port = orin->src_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.src_addr = orin->addr_v6.dst_addr;
out->addr_v6.dst_addr = orin->addr_v6.src_addr; out->addr_v6.dst_addr = orin->addr_v6.src_addr;
out->src_port = orin->dst_port; 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 // session_addr : deep copy
// value : shallow copy (malloc by user, free by value_free_cb) // 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; struct session_node *temp = NULL;
HASH_FIND(hh1, table->root_by_id, &session_id, sizeof(session_id), temp); 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); assert(temp);
temp->session_id = session_id; 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 = value;
temp->value_free_cb = value_free_cb; 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; 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; 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) if (!temp)
{ {
struct addr_tuple4 reverse_addr; struct four_tuple reverse_addr;
addr_tuple4_reverse(session_addr, &reverse_addr); four_tuple_reverse(session_addr, &reverse_addr);
HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct addr_tuple4), temp); HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct four_tuple), temp);
if (!temp) if (!temp)
{ {
return -1; return -1;
@@ -179,15 +179,15 @@ struct session_node *session_table_search_by_id(struct session_table *table, uin
return temp; 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; 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) if (!temp)
{ {
struct addr_tuple4 reverse_addr; struct four_tuple reverse_addr;
addr_tuple4_reverse(session_addr, &reverse_addr); four_tuple_reverse(session_addr, &reverse_addr);
HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct addr_tuple4), temp); HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct four_tuple), temp);
if (!temp) if (!temp)
{ {
return NULL; 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) add_executable(gtest_four_tuple gtest_four_tuple.cpp)
target_include_directories(gtest_addr_tuple4 PUBLIC ${CMAKE_SOURCE_DIR}/common/include) target_include_directories(gtest_four_tuple PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_addr_tuple4 common gtest) target_link_libraries(gtest_four_tuple common gtest)
############################################################################### ###############################################################################
# gtest_session_table # gtest_session_table
@@ -51,7 +51,7 @@ target_link_libraries(gtest_health_check_table common gtest platform)
############################################################################### ###############################################################################
include(GoogleTest) include(GoogleTest)
gtest_discover_tests(gtest_addr_tuple4) gtest_discover_tests(gtest_four_tuple)
gtest_discover_tests(gtest_session_table) gtest_discover_tests(gtest_session_table)
gtest_discover_tests(gtest_data_packet) gtest_discover_tests(gtest_data_packet)
gtest_discover_tests(gtest_control_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 <arpa/inet.h>
#include "data_packet.h" #include "data_packet.h"
#include "addr_tuple4.h" #include "four_tuple.h"
/****************************************************************************** /******************************************************************************
* Pcap file: 1-ETH_VLAN_VLAN_IP4_IP4_UDP.pcap * 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(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data1 == 70); EXPECT_TRUE((char *)payload - (char *)&data1 == 70);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
free(inner_addr_str); free(inner_addr_str);
@@ -103,8 +103,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "69.67.35.146 0 41.202.46.110 0");
free(inner_addr_str); free(inner_addr_str);
@@ -213,8 +213,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data2 == 94); EXPECT_TRUE((char *)payload - (char *)&data2 == 94);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "1.1.1.1 57639 2.2.2.2 22");
free(inner_addr_str); free(inner_addr_str);
@@ -233,8 +233,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2001::192:168:40:134 0 2001::192:168:40:133 0");
free(inner_addr_str); 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(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data3 == 126); EXPECT_TRUE((char *)payload - (char *)&data3 == 126);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "8.8.8.8 53 172.16.44.3 9879");
free(inner_addr_str); 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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2607:fcd0:100:2300::b108:2a6b 0 2402:f000:1:8e01::5555 0");
free(inner_addr_str); free(inner_addr_str);
@@ -438,8 +438,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data4 == 106); EXPECT_TRUE((char *)payload - (char *)&data4 == 106);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
free(inner_addr_str); free(inner_addr_str);
@@ -458,8 +458,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "210.77.88.163 0 59.66.4.50 0");
free(inner_addr_str); free(inner_addr_str);
@@ -523,8 +523,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data5 == 102); EXPECT_TRUE((char *)payload - (char *)&data5 == 102);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr); outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000"); EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000");
EXPECT_STREQ(outer_addr_str, "dead::beef 30000 cafe::babe 13000"); EXPECT_STREQ(outer_addr_str, "dead::beef 30000 cafe::babe 13000");
free(inner_addr_str); free(inner_addr_str);
@@ -543,8 +543,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr); outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 0 cafe::babe 0"); 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"); 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); free(inner_addr_str);
@@ -615,8 +615,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data6 == 70); EXPECT_TRUE((char *)payload - (char *)&data6 == 70);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "119.40.37.65 61853 123.125.29.250 80");
free(inner_addr_str); free(inner_addr_str);
@@ -635,8 +635,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "119.40.37.65 0 123.125.29.250 0");
free(inner_addr_str); free(inner_addr_str);
@@ -712,8 +712,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data7 == 66); EXPECT_TRUE((char *)payload - (char *)&data7 == 66);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "10.31.0.1 11001 10.34.0.1 23");
free(inner_addr_str); free(inner_addr_str);
@@ -732,8 +732,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "10.31.0.1 0 10.34.0.1 0");
free(inner_addr_str); free(inner_addr_str);
@@ -814,8 +814,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data8 == 78); EXPECT_TRUE((char *)payload - (char *)&data8 == 78);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "100.65.55.0 34532 91.185.14.33 443");
free(inner_addr_str); free(inner_addr_str);
@@ -834,8 +834,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
memset(&outer_addr, 0, sizeof(outer_addr)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "100.65.55.0 0 91.185.14.33 0");
free(inner_addr_str); free(inner_addr_str);
@@ -975,8 +975,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data9 == 130); EXPECT_TRUE((char *)payload - (char *)&data9 == 130);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2409:8034:4040:5300::105 2152 2409:8034:4025::60:61 2152");
free(inner_addr_str); 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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2409:8034:4040:5300::105 0 2409:8034:4025::60:61 0");
free(inner_addr_str); free(inner_addr_str);
@@ -1143,8 +1143,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data10 == 122); EXPECT_TRUE((char *)payload - (char *)&data10 == 122);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2409:8034:4025::50:a31 2152 2409:8034:4040:5301::204 2152");
free(inner_addr_str); 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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "2409:8034:4025::50:a31 0 2409:8034:4040:5301::204 0");
free(inner_addr_str); 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(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data11 == 92); EXPECT_TRUE((char *)payload - (char *)&data11 == 92);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
char *inner_addr_str = NULL; char *inner_addr_str = NULL;
char *outer_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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "10.1.1.1 50709 192.168.1.10 4789");
free(inner_addr_str); 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)); memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr); inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_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(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"); EXPECT_STREQ(outer_addr_str, "10.1.1.1 0 192.168.1.10 0");
free(inner_addr_str); free(inner_addr_str);
@@ -1325,8 +1325,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
EXPECT_TRUE(payload != nullptr); EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data12 == 40); EXPECT_TRUE((char *)payload - (char *)&data12 == 40);
struct addr_tuple4 inner_addr; struct four_tuple inner_addr;
struct addr_tuple4 outer_addr; struct four_tuple outer_addr;
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1); EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_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 <gtest/gtest.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include "addr_tuple4.h" #include "four_tuple.h"
TEST(ADDR_TUPLE4, IPV4) TEST(ADDR_TUPLE4, IPV4)
{ {
char *ret_str = NULL; 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) 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_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "1.2.3.4 12345 4.3.2.1 23456"); EXPECT_STREQ(ret_str, "1.2.3.4 12345 4.3.2.1 23456");
free(ret_str); 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_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "4.3.2.1 23456 1.2.3.4 12345"); EXPECT_STREQ(ret_str, "4.3.2.1 23456 1.2.3.4 12345");
free(ret_str); free(ret_str);
@@ -25,17 +25,17 @@ TEST(ADDR_TUPLE4, IPV4)
TEST(ADDR_TUPLE4, IPV6) TEST(ADDR_TUPLE4, IPV6)
{ {
char *ret_str = NULL; 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); 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_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "1:2::3 12345 a:b::c 23456"); EXPECT_STREQ(ret_str, "1:2::3 12345 a:b::c 23456");
free(ret_str); 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_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "a:b::c 23456 1:2::3 12345"); EXPECT_STREQ(ret_str, "a:b::c 23456 1:2::3 12345");
free(ret_str); 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"); char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321); 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); INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse; struct four_tuple addr1_reverse;
struct addr_tuple4 addr2_reverse; struct four_tuple addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse); four_tuple_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse); four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert // TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0); 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"); char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321); 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); INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse; struct four_tuple addr1_reverse;
struct addr_tuple4 addr2_reverse; struct four_tuple addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse); four_tuple_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse); four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert // TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0); 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"); char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321); 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); INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse; struct four_tuple addr1_reverse;
struct addr_tuple4 addr2_reverse; struct four_tuple addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse); four_tuple_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse); four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert // TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0); 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"); char *val_world = strdup("WORLD");
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321); 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); INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct addr_tuple4 addr1_reverse; struct four_tuple addr1_reverse;
struct addr_tuple4 addr2_reverse; struct four_tuple addr2_reverse;
addr_tuple4_reverse(&addr1, &addr1_reverse); four_tuple_reverse(&addr1, &addr1_reverse);
addr_tuple4_reverse(&addr2, &addr2_reverse); four_tuple_reverse(&addr2, &addr2_reverse);
// TEST Insert // TEST Insert
EXPECT_TRUE(session_table_insert(table, 1, &addr1, val_hello, free) == 0); 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; uint64_t session_id;
char *session_addr; char *session_addr;
struct addr_tuple4 inner_tuple4; struct four_tuple inner_tuple4;
struct mutable_array rule_ids; struct mutable_array rule_ids;
struct metadata *decrypted_meta_i2e; 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 // 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) 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 four_tuple inner_addr;
struct addr_tuple4 reverse_addr; struct four_tuple reverse_addr;
struct data_packet data_pkt; struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4)); memset(&inner_addr, 0, sizeof(struct four_tuple));
memset(&reverse_addr, 0, sizeof(struct addr_tuple4)); memset(&reverse_addr, 0, sizeof(struct four_tuple));
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0); data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr); 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); struct session_node *node = session_table_search_by_id(table, session_id);
if (node == NULL) 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; 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); 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); free(addr_str);
return NULL; return NULL;
@@ -381,10 +381,10 @@ static struct session_ctx *data_packet_search_session(struct session_table *tabl
// return NULL // return NULL
static struct session_ctx *inject_packet_search_session(struct session_table *table, const char *raw_data, int raw_len) 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; 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); 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); struct session_node *node = session_table_search_by_addr(table, &inner_addr);
if (node == NULL) 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); LOG_ERROR("%s: unexpected inject packet, unable to find session %s from session table, drop !!!", LOG_TAG_PKTIO, addr_str);
free(addr_str); free(addr_str);
return NULL; return NULL;
@@ -914,21 +914,21 @@ static void handle_session_opening(struct metadata *meta, struct control_packet
#endif #endif
struct data_packet data_pkt; 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); 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); data_packet_get_innermost_tuple4(&data_pkt, &inner_tuple4);
uint16_t real_offset = (char *)payload - meta->raw_data; uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset) 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); 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); free(addr_str);
} }
struct session_ctx *session_ctx = session_ctx_new(); struct session_ctx *session_ctx = session_ctx_new();
session_ctx->session_id = meta->session_id; session_ctx->session_id = meta->session_id;
session_ctx->session_addr = addr_tuple4_to_str(&inner_tuple4); session_ctx->session_addr = four_tuple_to_string(&inner_tuple4);
addr_tuple4_copy(&session_ctx->inner_tuple4, &inner_tuple4); four_tuple_copy(&session_ctx->inner_tuple4, &inner_tuple4);
metadata_deep_copy(session_ctx->ctrl_meta, meta); 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_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); session_ctx->chainings.chaining_decrypted = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);