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

30
common/src/data_packet.cpp
View File

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

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

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

24
common/src/session_table.cpp
View File

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