From 8fe574633bc7ad96b42f5c8996821fc5afa42e18 Mon Sep 17 00:00:00 2001 From: luwenpeng Date: Wed, 8 Nov 2023 10:20:27 +0800 Subject: [PATCH] perf: rename addr_tuple4 to four_tuple --- common/CMakeLists.txt | 2 +- common/include/data_packet.h | 8 +- .../include/{addr_tuple4.h => four_tuple.h} | 28 ++-- common/include/session_table.h | 10 +- common/src/data_packet.cpp | 30 ++-- .../src/{addr_tuple4.cpp => four_tuple.cpp} | 24 +-- common/src/session_table.cpp | 24 +-- common/test/CMakeLists.txt | 10 +- common/test/gtest_data_packet.cpp | 138 +++++++++--------- ...t_addr_tuple4.cpp => gtest_four_tuple.cpp} | 18 +-- common/test/gtest_session_table.cpp | 32 ++-- platform/include/sce.h | 2 +- platform/src/packet_io.cpp | 28 ++-- 13 files changed, 177 insertions(+), 177 deletions(-) rename common/include/{addr_tuple4.h => four_tuple.h} (71%) rename common/src/{addr_tuple4.cpp => four_tuple.cpp} (76%) rename common/test/{gtest_addr_tuple4.cpp => gtest_four_tuple.cpp} (69%) diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 6a2aebe..ec8e47d 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -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) diff --git a/common/include/data_packet.h b/common/include/data_packet.h index fc0a8d4..e902b5e 100644 --- a/common/include/data_packet.h +++ b/common/include/data_packet.h @@ -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); diff --git a/common/include/addr_tuple4.h b/common/include/four_tuple.h similarity index 71% rename from common/include/addr_tuple4.h rename to common/include/four_tuple.h index d7cfd6d..ac81dac 100644 --- a/common/include/addr_tuple4.h +++ b/common/include/four_tuple.h @@ -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 -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 } diff --git a/common/include/session_table.h b/common/include/session_table.h index b34ee35..e92c1c5 100644 --- a/common/include/session_table.h +++ b/common/include/session_table.h @@ -10,7 +10,7 @@ extern "C" #include #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 } diff --git a/common/src/data_packet.cpp b/common/src/data_packet.cpp index cb18af5..1142e25 100644 --- a/common/src/data_packet.cpp +++ b/common/src/data_packet.cpp @@ -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; diff --git a/common/src/addr_tuple4.cpp b/common/src/four_tuple.cpp similarity index 76% rename from common/src/addr_tuple4.cpp rename to common/src/four_tuple.cpp index 0ea325a..cf0c529 100644 --- a/common/src/addr_tuple4.cpp +++ b/common/src/four_tuple.cpp @@ -2,15 +2,15 @@ #include #include -#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; diff --git a/common/src/session_table.cpp b/common/src/session_table.cpp index 1bbbfd3..f8592dc 100644 --- a/common/src/session_table.cpp +++ b/common/src/session_table.cpp @@ -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; diff --git a/common/test/CMakeLists.txt b/common/test/CMakeLists.txt index ff72650..07d44f4 100644 --- a/common/test/CMakeLists.txt +++ b/common/test/CMakeLists.txt @@ -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) diff --git a/common/test/gtest_data_packet.cpp b/common/test/gtest_data_packet.cpp index e713f79..bd34c57 100644 --- a/common/test/gtest_data_packet.cpp +++ b/common/test/gtest_data_packet.cpp @@ -2,7 +2,7 @@ #include #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); diff --git a/common/test/gtest_addr_tuple4.cpp b/common/test/gtest_four_tuple.cpp similarity index 69% rename from common/test/gtest_addr_tuple4.cpp rename to common/test/gtest_four_tuple.cpp index ad9b246..7fce8a0 100644 --- a/common/test/gtest_addr_tuple4.cpp +++ b/common/test/gtest_four_tuple.cpp @@ -1,22 +1,22 @@ #include #include -#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); diff --git a/common/test/gtest_session_table.cpp b/common/test/gtest_session_table.cpp index a804454..22c5252 100644 --- a/common/test/gtest_session_table.cpp +++ b/common/test/gtest_session_table.cpp @@ -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); diff --git a/platform/include/sce.h b/platform/include/sce.h index 67e648a..7cff177 100644 --- a/platform/include/sce.h +++ b/platform/include/sce.h @@ -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; diff --git a/platform/src/packet_io.cpp b/platform/src/packet_io.cpp index 60dff88..de85072 100644 --- a/platform/src/packet_io.cpp +++ b/platform/src/packet_io.cpp @@ -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);