gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reactor packet I/O & duplicated packet filter & evicted session filter

Browse Source
This commit is contained in:
luwenpeng
2024-03-09 19:28:14 +08:00
parent ee35a26a9d
commit 512dfddd03
79 changed files with 1974 additions and 2093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/packet/CMakeLists.txt
View File

@@ -1,8 +1,4 @@
###############################################################################
# packet
###############################################################################
add_library(packet packet.cpp packet_utils.cpp)
add_library(packet packet.cpp)
target_include_directories(packet PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/deps/uthash)
target_link_libraries(packet tuple log)

584
src/packet/packet.cpp
View File

File diff suppressed because it is too large Load Diff

150
src/packet/packet.h
View File

@@ -11,10 +11,9 @@ extern "C"
#include "tuple.h"
#include "log.h"
#define PACKET_MAX_LAYERS 16
#define PACKET_MAX_LAYERS 32
#define PACKET_LOG_ERROR(format, ...) LOG_ERROR("packet", format, ##__VA_ARGS__)
#define PACKET_LOG_DEBUG(format, ...) void(0)
// #define PACKET_LOG_DEBUG(format, ...) LOG_DEBUG("packet", format, ##__VA_ARGS__)
#define PACKET_LOG_DEBUG(format, ...) LOG_DEBUG("packet", format, ##__VA_ARGS__)
enum layer_type
{
@@ -61,7 +60,49 @@ enum ldbc_method
LDBC_METHOD_HASH_INNERMOST_EXT_IP = 5,
};
struct layer_record
enum packet_direction
{
PACKET_DIRECTION_I2E = 0,
PACKET_DIRECTION_E2I = 1,
};
enum packet_action
{
PACKET_ACTION_FORWARD = 0,
PACKET_ACTION_DROP = 1,
};
enum packet_type
{
PACKET_TYPE_DATA = 0,
PACKET_TYPE_CTRL = 1,
};
struct metadata
{
#define MAX_SID_NUM 8
#define MAX_ROUTE_LEN 64
struct
{
uint16_t list[MAX_SID_NUM];
uint16_t used;
} sid;
struct
{
char data[MAX_ROUTE_LEN];
uint16_t len;
} route;
void *user_data;
uint64_t domain;
uint64_t session_id;
enum packet_direction direction;
enum packet_action action;
enum packet_type type;
};
struct layer
{
enum layer_type type;
const char *hdr_ptr; // header pointer
@@ -71,61 +112,90 @@ struct layer_record
uint16_t pld_len; // payload length
};
#define MAX_SID_NUM 8
#define MAX_ROUTE_LEN 64
struct packet
{
struct layer_record layers[PACKET_MAX_LAYERS];
struct layer_record *frag_layer; // fragment layer
struct layer layers[PACKET_MAX_LAYERS];
struct layer *frag_layer; // fragment layer
int8_t layers_used;
int8_t layers_size;
const char *data_ptr;
uint16_t data_len;
uint64_t domain;
bool need_free;
// metadata
void *io_ctx;
uint16_t sid_list[MAX_SID_NUM];
uint16_t sid_used;
char route_ctx[MAX_ROUTE_LEN];
uint16_t route_len;
uint64_t session_id;
uint8_t direction;
uint8_t type;
uint8_t action;
struct metadata meta;
};
// return innermost payload
const char *packet_parse(struct packet *handler, const char *data, uint16_t len);
void packet_print(const struct packet *handler);
const char *packet_parse(struct packet *pkt, const char *data, uint16_t len);
void packet_print(const struct packet *pkt);
// return 0 : found
// return -1 : not found
int packet_get_innermost_tuple2(const struct packet *handler, struct tuple2 *tuple);
int packet_get_outermost_tuple2(const struct packet *handler, struct tuple2 *tuple);
// return 0: found
// return -1: not found
int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple);
int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple);
// return 0 : found
// return -1 : not found
int packet_get_innermost_tuple4(const struct packet *handler, struct tuple4 *tuple);
int packet_get_outermost_tuple4(const struct packet *handler, struct tuple4 *tuple);
// return 0: found
// return -1: not found
int packet_get_innermost_tuple4(const struct packet *pkt, struct tuple4 *tuple);
int packet_get_outermost_tuple4(const struct packet *pkt, struct tuple4 *tuple);
// return 0 : found
// return -1 : not found
int packet_get_innermost_tuple6(const struct packet *handler, struct tuple6 *tuple);
int packet_get_outermost_tuple6(const struct packet *handler, struct tuple6 *tuple);
// return 0: found
// return -1: not found
int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple);
int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple);
const struct layer_record *packet_get_innermost_layer(const struct packet *handler, enum layer_type type);
const struct layer_record *packet_get_outermost_layer(const struct packet *handler, enum layer_type type);
const struct layer *packet_get_innermost_layer(const struct packet *pkt, enum layer_type type);
const struct layer *packet_get_outermost_layer(const struct packet *pkt, enum layer_type type);
// direction 1: E2I
// direction 0: I2E
uint64_t packet_get_hash(const struct packet *handler, enum ldbc_method method, int direction);
uint64_t packet_get_hash(const struct packet *pkt, enum ldbc_method method, int direction);
// return 0: success
// return -1: failed
int packet_set_sid(struct packet *pkt, uint16_t *sid, int num);
// return number of sid
int packet_get_sid(const struct packet *pkt, uint16_t *sid, int size);
// return 0: success
// return -1: failed
int packet_prepend_sid(struct packet *pkt, uint16_t sid);
// return 0: success
// return -1: failed
int packet_append_sid(struct packet *pkt, uint16_t sid);
// return 0: success
// return -1: failed
int packet_set_route_ctx(struct packet *pkt, const char *route, int len);
// return len of route ctx
int packet_get_route_ctx(const struct packet *pkt, char *buff, int size);
void packet_set_user_data(struct packet *pkt, void *user_data);
void *packet_get_user_data(const struct packet *pkt);
void packet_set_domain(struct packet *pkt, uint64_t domain);
uint64_t packet_get_domain(const struct packet *pkt);
void packet_set_session_id(struct packet *pkt, uint64_t session_id);
uint64_t packet_get_session_id(const struct packet *pkt);
void packet_set_direction(struct packet *pkt, enum packet_direction direction);
enum packet_direction packet_get_direction(const struct packet *pkt);
void packet_set_action(struct packet *pkt, enum packet_action action);
enum packet_action packet_get_action(const struct packet *pkt);
void packet_set_type(struct packet *pkt, enum packet_type type);
enum packet_type packet_get_type(const struct packet *pkt);
struct packet *packet_new(uint16_t pkt_len);
void packet_free(struct packet *pkt);
struct packet *packet_dup(const struct packet *pkt);
const char *packet_get_data(const struct packet *pkt);
uint16_t packet_get_len(const struct packet *pkt);
bool packet_is_fragment(const struct packet *pkt);
#ifdef __cpluscplus
}

202
src/packet/packet_utils.cpp
View File

@@ -1,202 +0,0 @@
#include "packet_utils.h"
void packet_set_io_ctx(struct packet *pkt, void *ctx)
{
pkt->io_ctx = ctx;
}
void *packet_get_io_ctx(const struct packet *pkt)
{
return pkt->io_ctx;
}
// return 0 success; return -1 failed
int packet_set_sid(struct packet *pkt, uint16_t *sid, int num)
{
if (num > MAX_SID_NUM)
{
return -1;
}
pkt->sid_used = num;
memcpy(pkt->sid_list, sid, num * sizeof(uint16_t));
return 0;
}
// return number of sid
int packet_get_sid(const struct packet *pkt, uint16_t *sid, int size)
{
if (size < pkt->sid_used)
{
return 0;
}
memcpy(sid, pkt->sid_list, pkt->sid_used * sizeof(uint16_t));
return pkt->sid_used;
}
// return 0 success; return -1 failed
int packet_prepend_sid(struct packet *pkt, uint16_t sid)
{
if (pkt->sid_used >= MAX_SID_NUM)
{
return -1;
}
memmove(pkt->sid_list + 1, pkt->sid_list, pkt->sid_used * sizeof(uint16_t));
pkt->sid_list[0] = sid;
pkt->sid_used++;
return 0;
}
// return 0 success; return -1 failed
int packet_append_sid(struct packet *pkt, uint16_t sid)
{
if (pkt->sid_used >= MAX_SID_NUM)
{
return -1;
}
pkt->sid_list[pkt->sid_used] = sid;
pkt->sid_used++;
return 0;
}
// return 0 success; return -1 failed
int packet_set_route_ctx(struct packet *pkt, const char *route, int len)
{
if (len > MAX_ROUTE_LEN)
{
return -1;
}
memcpy(pkt->route_ctx, route, len);
pkt->route_len = len;
return 0;
}
// return len of route ctx
int packet_get_route_ctx(const struct packet *pkt, char *buff, int size)
{
if (pkt->route_len > size)
{
return 0;
}
memcpy(buff, pkt->route_ctx, pkt->route_len);
return pkt->route_len;
}
void packet_set_session_id(struct packet *pkt, uint64_t session_id)
{
pkt->session_id = session_id;
}
uint64_t packet_get_session_id(const struct packet *pkt)
{
return pkt->session_id;
}
void packet_set_direction(struct packet *pkt, uint8_t direction)
{
pkt->direction = direction;
}
uint8_t packet_get_direction(const struct packet *pkt)
{
return pkt->direction;
}
void packet_set_type(struct packet *pkt, uint8_t type)
{
pkt->type = type;
}
uint8_t packet_get_type(const struct packet *pkt)
{
return pkt->type;
}
void packet_set_action(struct packet *pkt, uint8_t action)
{
pkt->action = action;
}
uint8_t packet_get_action(const struct packet *pkt)
{
return pkt->action;
}
struct packet *packet_new(uint16_t len)
{
struct packet *pkt = (struct packet *)calloc(1, sizeof(struct packet) + len);
if (pkt == NULL)
{
return NULL;
}
pkt->data_len = len;
pkt->data_ptr = (const char *)pkt + sizeof(struct packet);
pkt->need_free = true;
return pkt;
}
void packet_free(struct packet *pkt)
{
if (pkt && pkt->need_free)
{
free(pkt);
pkt = NULL;
}
}
struct packet *packet_dup(const struct packet *pkt)
{
if (pkt == NULL)
{
return NULL;
}
struct packet *pkt_dup = packet_new(pkt->data_len);
if (pkt_dup == NULL)
{
return NULL;
}
memcpy(pkt_dup, pkt, sizeof(struct packet));
memcpy((char *)pkt_dup->data_ptr, pkt->data_ptr, pkt->data_len);
pkt_dup->need_free = true;
// update layers
for (int8_t i = 0; i < pkt->layers_used; i++)
{
pkt_dup->layers[i].hdr_ptr = pkt_dup->data_ptr + pkt->layers[i].hdr_offset;
pkt_dup->layers[i].pld_ptr = pkt_dup->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
}
// update frag_layer
if (pkt->frag_layer)
{
pkt_dup->frag_layer = &pkt_dup->layers[pkt->frag_layer - pkt->layers];
}
return pkt_dup;
}
const char *packet_get_data(const struct packet *pkt)
{
return pkt->data_ptr;
}
uint16_t packet_get_len(const struct packet *pkt)
{
return pkt->data_len;
}
bool paket_is_fragment(const struct packet *pkt)
{
if (pkt->frag_layer)
{
return true;
}
else
{
return false;
}
}

59
src/packet/packet_utils.h
View File

@@ -1,59 +0,0 @@
#ifndef _PACKET_UTILS_H
#define _PACKET_UTILS_H
#ifdef __cpluscplus
extern "C"
{
#endif
#include <stdlib.h>
#include <string.h>
#include "packet.h"
void packet_set_io_ctx(struct packet *pkt, void *ctx);
void *packet_get_io_ctx(const struct packet *pkt);
int packet_set_sid(struct packet *pkt, uint16_t *sid, int num); // return 0 success; return -1 failed
int packet_get_sid(const struct packet *pkt, uint16_t *sid, int size); // return number of sid
int packet_prepend_sid(struct packet *pkt, uint16_t sid); // return 0 success; return -1 failed
int packet_append_sid(struct packet *pkt, uint16_t sid); // return 0 success; return -1 failed
int packet_set_route_ctx(struct packet *pkt, const char *route, int len); // return 0 success; return -1 failed
int packet_get_route_ctx(const struct packet *pkt, char *buff, int size); // return len of route ctx
void packet_set_session_id(struct packet *pkt, uint64_t session_id);
uint64_t packet_get_session_id(const struct packet *pkt);
#define PACKET_DIRECTION_I2E 0
#define PACKET_DIRECTION_E2I 1
void packet_set_direction(struct packet *pkt, uint8_t direction);
uint8_t packet_get_direction(const struct packet *pkt);
#define PACKET_TYPE_DATA 0
#define PACKET_TYPE_CTRL 1
void packet_set_type(struct packet *pkt, uint8_t type);
uint8_t packet_get_type(const struct packet *pkt);
#define PACKET_ACTION_FORWARD 0
#define PACKET_ACTION_DROP 1
void packet_set_action(struct packet *pkt, uint8_t action);
uint8_t packet_get_action(const struct packet *pkt);
struct packet *packet_new(uint16_t len);
void packet_free(struct packet *pkt);
struct packet *packet_dup(const struct packet *pkt);
const char *packet_get_data(const struct packet *pkt);
uint16_t packet_get_len(const struct packet *pkt);
bool paket_is_fragment(const struct packet *pkt);
#ifdef __cpluscplus
}
#endif
#endif

10
src/packet/test/CMakeLists.txt
View File

@@ -1,7 +1,3 @@
###############################################################################
# gtest
###############################################################################
add_executable(gtest_packet gtest_packet.cpp)
target_link_libraries(gtest_packet packet gtest)
@@ -17,8 +13,8 @@ target_link_libraries(gtest_ipv4_utils packet gtest)
add_executable(gtest_ipv6_utils gtest_ipv6_utils.cpp)
target_link_libraries(gtest_ipv6_utils packet gtest)
add_executable(gtest_packet_utils gtest_packet_utils.cpp)
target_link_libraries(gtest_packet_utils packet gtest)
add_executable(gtest_packet_frag gtest_packet_frag.cpp)
target_link_libraries(gtest_packet_frag packet gtest)
include(GoogleTest)
gtest_discover_tests(gtest_packet)
@@ -26,4 +22,4 @@ gtest_discover_tests(gtest_udp_utils)
gtest_discover_tests(gtest_tcp_utils)
gtest_discover_tests(gtest_ipv4_utils)
gtest_discover_tests(gtest_ipv6_utils)
gtest_discover_tests(gtest_packet_utils)
gtest_discover_tests(gtest_packet_frag)

372
src/packet/test/gtest_packet.cpp
View File

File diff suppressed because it is too large Load Diff

26
src/packet/test/gtest_packet_utils.cpp → src/packet/test/gtest_packet_frag.cpp
View File

@@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include "packet_utils.h"
#include "packet.h"
/******************************************************************************
* [Protocols in frame: eth:ethertype:ip:data]
@@ -44,15 +44,15 @@ unsigned char data1[] = {
0x00, 0x00, 0x31, 0x32, 0x33, 0x0a, 0x00, 0x00};
#if 1
TEST(PACKET_UTILS, IPV4_FRAGMENT)
TEST(PACKET_FRAG, IPV4_FRAGMENT)
{
struct packet handler;
packet_parse(&handler, (const char *)data1, sizeof(data1));
EXPECT_TRUE(paket_is_fragment(&handler) == true);
EXPECT_TRUE(packet_is_fragment(&handler) == true);
struct packet *dup = packet_dup(&handler);
EXPECT_TRUE(dup != NULL);
EXPECT_TRUE(paket_is_fragment(dup) == true);
EXPECT_TRUE(packet_is_fragment(dup) == true);
packet_free(dup);
}
#endif
@@ -152,15 +152,15 @@ unsigned char data2[] = {
0x68, 0x68};
#if 1
TEST(PACKET_UTILS, IPV6_FRAGMENT)
TEST(PACKET_FRAG, IPV6_FRAGMENT)
{
struct packet handler;
packet_parse(&handler, (const char *)data2, sizeof(data2));
EXPECT_TRUE(paket_is_fragment(&handler) == true);
EXPECT_TRUE(packet_is_fragment(&handler) == true);
struct packet *dup = packet_dup(&handler);
EXPECT_TRUE(dup != NULL);
EXPECT_TRUE(paket_is_fragment(dup) == true);
EXPECT_TRUE(packet_is_fragment(dup) == true);
packet_free(dup);
}
#endif
@@ -228,15 +228,15 @@ unsigned char data3[] = {
0x04, 0x02};
#if 1
TEST(PACKET_UTILS, IPV4_IPV6_NOT_FRAGMENT)
TEST(PACKET_FRAG, IPV4_IPV6_NOT_FRAGMENT)
{
struct packet handler;
packet_parse(&handler, (const char *)data3, sizeof(data3));
EXPECT_TRUE(paket_is_fragment(&handler) == false);
EXPECT_TRUE(packet_is_fragment(&handler) == false);
struct packet *dup = packet_dup(&handler);
EXPECT_TRUE(dup != NULL);
EXPECT_TRUE(paket_is_fragment(dup) == false);
EXPECT_TRUE(packet_is_fragment(dup) == false);
packet_free(dup);
}
#endif
@@ -290,15 +290,15 @@ unsigned char data4[] = {
0x58, 0x58};
#if 1
TEST(PACKET_UTILS, IPV6_IPV6_NOT_FRAGMENT)
TEST(PACKET_FRAG, IPV6_IPV6_NOT_FRAGMENT)
{
struct packet handler;
packet_parse(&handler, (const char *)data4, sizeof(data4));
EXPECT_TRUE(paket_is_fragment(&handler) == false);
EXPECT_TRUE(packet_is_fragment(&handler) == false);
struct packet *dup = packet_dup(&handler);
EXPECT_TRUE(dup != NULL);
EXPECT_TRUE(paket_is_fragment(dup) == false);
EXPECT_TRUE(packet_is_fragment(dup) == false);
packet_free(dup);
}
#endif