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

Add packet utils to packet.h

Browse Source
This commit is contained in:
luwenpeng
2024-04-11 19:44:02 +08:00
parent 84541c40e2
commit 17f5d338de
32 changed files with 615 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
include/packet.h
View File

@@ -72,9 +72,36 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple);
const struct packet_layer *packet_get_innermost_layer(const struct packet *pkt, enum layer_type type);
const struct packet_layer *packet_get_outermost_layer(const struct packet *pkt, enum layer_type type);
/******************************************************************************
* Utils
******************************************************************************/
int8_t packet_get_layers(const struct packet *pkt);
const struct packet_layer *packet_get_layer(const struct packet *pkt, int8_t idx);
const char *packet_get_data(const struct packet *pkt);
uint16_t packet_get_len(const struct packet *pkt);
const char *packet_get_payload(const struct packet *pkt);
uint16_t packet_get_payload_len(const struct packet *pkt);
int packet_need_drop(const struct packet *pkt);
void packet_set_drop(struct packet *pkt);
void packet_set_ctrl(struct packet *pkt);
int packet_is_ctrl(const struct packet *pkt);
void packet_set_direction(struct packet *pkt, int dir);
int packet_get_direction(const struct packet *pkt); // 1: E2I, 0: I2E
void packet_set_session_id(struct packet *pkt, uint64_t sess_id);
uint64_t packet_get_session_id(const struct packet *pkt);
void packet_set_sid_list(struct packet *pkt, uint16_t *sid, int num);
int packet_get_sid_list(const struct packet *pkt, uint16_t *sid, int num); // return number of sid
void packet_prepend_sid_list(struct packet *pkt, uint16_t *sid, int num);
void packet_append_sid_list(struct packet *pkt, uint16_t *sid, int num);
/*
******************************************************************************
* Example: getting the innermost TCP layer

2
src/duplicated_packet_filter/duplicated_packet_filter.h
View File

@@ -9,7 +9,7 @@ extern "C"
// Duplicated Packet Filter for IPv4 Packet
#include "log.h"
#include "packet_private.h"
#include "packet.h"
#define DUPLICATED_PACKET_FILTER_LOG_ERROR(format, ...) LOG_ERROR("duplicated packet filter", format, ##__VA_ARGS__)

1
src/duplicated_packet_filter/test/gtest_duplicated_packet_filter.cpp
View File

@@ -1,6 +1,7 @@
#include <gtest/gtest.h>
#include "duplicated_packet_filter.h"
#include "packet_private.h"
/******************************************************************************
* [Protocols in frame: eth:ethertype:ip:ipv6:tcp]

2
src/ip_reassembly/ip_reassembly.cpp
View File

@@ -729,7 +729,7 @@ static struct packet *ip_frag_reassemble(struct ip_reassembly *assy, struct ip_f
// create a new packet
packet_parse(pkt, ptr, packet_len);
packet_set_action(pkt, PACKET_ACTION_DROP);
packet_set_drop(pkt);
return pkt;

2
src/ip_reassembly/ip_reassembly.h
View File

@@ -6,7 +6,7 @@ extern "C"
{
#endif
#include "packet_private.h"
#include "packet.h"
#include "log.h"
#define IP_REASSEMBLE_DEBUG(format, ...) LOG_DEBUG("ip_reassembly", format, ##__VA_ARGS__)

1
src/ip_reassembly/test/gtest_utils.h
View File

@@ -13,6 +13,7 @@ extern "C"
#include "ipv4_utils.h"
#include "ipv6_utils.h"
#include "ip_reassembly.h"
#include "packet_private.h"
static inline void packet_set_ipv4_src_addr(struct packet *pkt, uint32_t saddr)
{

2
src/log/log.cpp
View File

@@ -272,7 +272,7 @@ void log_print(enum log_level level, const char *module, const char *fmt, ...)
}
int nwrite;
char buf[2048] = {0};
char buf[4096] = {0};
char *p = buf;
char *end = buf + sizeof(buf);
va_list args;

4
src/packet/CMakeLists.txt
View File

@@ -1,7 +1,7 @@
add_library(packet packet.cpp)
add_library(packet packet.cpp packet_utils.cpp)
target_include_directories(packet PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/deps/uthash)
target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/include)
target_link_libraries(packet tuple log)
target_link_libraries(packet tuple log mrzcpd)
add_subdirectory(test)

289
src/packet/packet.cpp
View File

@@ -1131,7 +1131,6 @@ const char *packet_parse(struct packet *pkt, const char *data, uint16_t len)
pkt->layers_size = PACKET_MAX_LAYERS;
pkt->data_ptr = data;
pkt->data_len = len;
memset(&pkt->meta, 0, sizeof(struct metadata));
// TESTED
return parse_ether(pkt, data, len);
@@ -1291,7 +1290,7 @@ int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
const struct packet_layer *layer_l3 = NULL;
const struct packet_layer *layer_l4 = NULL;
const struct packet_layer *layer = NULL;
const struct metadata *meta = &pkt->meta;
uint64_t domain = packet_get_domain(pkt);
for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
{
@@ -1312,10 +1311,10 @@ int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
}
}
if (layer_l3 && layer_l4)
if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
{
set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, meta->domain);
set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, meta->domain);
set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, domain);
set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, domain);
return 0;
}
else
@@ -1332,7 +1331,7 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
const struct packet_layer *layer_l3 = NULL;
const struct packet_layer *layer_l4 = NULL;
const struct packet_layer *layer = NULL;
const struct metadata *meta = &pkt->meta;
uint64_t domain = packet_get_domain(pkt);
for (int8_t i = 0; i < pkt->layers_used; i++)
{
@@ -1353,10 +1352,10 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
}
}
if (layer_l3 && layer_l4)
if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
{
set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, meta->domain);
set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, meta->domain);
set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, domain);
set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, domain);
return 0;
}
else
@@ -1516,275 +1515,3 @@ uint64_t packet_get_hash(const struct packet *pkt, enum ldbc_method method, int
return hash_value;
}
int8_t packet_get_layers(const struct packet *pkt)
{
return pkt->layers_used;
}
const struct packet_layer *packet_get_layer(const struct packet *pkt, int8_t idx)
{
if (idx < 0 || idx >= pkt->layers_used)
{
return NULL;
}
return &pkt->layers[idx];
}
/******************************************************************************
* Packet Meta Data
******************************************************************************/
// return 0 : success
// return -1 : failed
int packet_set_sid(struct packet *pkt, uint16_t *sid, int num)
{
struct metadata *meta = &pkt->meta;
if (num > MAX_SID_NUM)
{
return -1;
}
meta->sid.used = num;
memcpy(meta->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)
{
const struct metadata *meta = &pkt->meta;
if (size < meta->sid.used)
{
return 0;
}
memcpy(sid, meta->sid.list, meta->sid.used * sizeof(uint16_t));
return meta->sid.used;
}
// return 0 : success
// return -1 : failed
int packet_prepend_sid(struct packet *pkt, uint16_t sid)
{
struct metadata *meta = &pkt->meta;
if (meta->sid.used >= MAX_SID_NUM)
{
return -1;
}
memmove(meta->sid.list + 1, meta->sid.list, meta->sid.used * sizeof(uint16_t));
meta->sid.list[0] = sid;
meta->sid.used++;
return 0;
}
// return 0 : success
// return -1 : failed
int packet_append_sid(struct packet *pkt, uint16_t sid)
{
struct metadata *meta = &pkt->meta;
if (meta->sid.used >= MAX_SID_NUM)
{
return -1;
}
meta->sid.list[meta->sid.used] = sid;
meta->sid.used++;
return 0;
}
// return 0 : success
// return -1 : failed
int packet_set_route_ctx(struct packet *pkt, const char *route, int len)
{
struct metadata *meta = &pkt->meta;
if (len > MAX_ROUTE_LEN)
{
return -1;
}
memcpy(meta->route.data, route, len);
meta->route.len = len;
return 0;
}
// return len of route ctx
int packet_get_route_ctx(const struct packet *pkt, char *buff, int size)
{
const struct metadata *meta = &pkt->meta;
if (meta->route.len > size)
{
return 0;
}
memcpy(buff, meta->route.data, meta->route.len);
return meta->route.len;
}
void packet_set_io_ctx(struct packet *pkt, void *ctx)
{
struct metadata *meta = &pkt->meta;
meta->io_ctx = ctx;
}
void *packet_get_io_ctx(const struct packet *pkt)
{
const struct metadata *meta = &pkt->meta;
return meta->io_ctx;
}
void packet_set_domain(struct packet *pkt, uint64_t domain)
{
struct metadata *meta = &pkt->meta;
meta->domain = domain;
}
uint64_t packet_get_domain(const struct packet *pkt)
{
const struct metadata *meta = &pkt->meta;
return meta->domain;
}
void packet_set_session_id(struct packet *pkt, uint64_t session_id)
{
struct metadata *meta = &pkt->meta;
meta->session_id = session_id;
}
uint64_t packet_get_session_id(const struct packet *pkt)
{
const struct metadata *meta = &pkt->meta;
return meta->session_id;
}
void packet_set_direction(struct packet *pkt, enum packet_direction direction)
{
struct metadata *meta = &pkt->meta;
meta->direction = direction;
}
enum packet_direction packet_get_direction(const struct packet *pkt)
{
const struct metadata *meta = &pkt->meta;
return meta->direction;
}
void packet_set_action(struct packet *pkt, enum packet_action action)
{
struct metadata *meta = &pkt->meta;
meta->action = action;
}
enum packet_action packet_get_action(const struct packet *pkt)
{
const struct metadata *meta = &pkt->meta;
return meta->action;
}
void packet_set_type(struct packet *pkt, enum packet_type type)
{
struct metadata *meta = &pkt->meta;
meta->type = type;
}
enum packet_type packet_get_type(const struct packet *pkt)
{
const struct metadata *meta = &pkt->meta;
return meta->type;
}
struct packet *packet_new(uint16_t pkt_len)
{
struct packet *pkt = (struct packet *)calloc(1, sizeof(struct packet) + pkt_len);
if (pkt == NULL)
{
return NULL;
}
pkt->data_len = pkt_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)
{
pkt->need_free = false;
free((void *)pkt);
}
}
struct packet *packet_dup(const struct packet *pkt)
{
if (pkt == NULL)
{
return NULL;
}
struct packet *dup_pkt = packet_new(pkt->data_len);
if (dup_pkt == NULL)
{
return NULL;
}
memcpy(dup_pkt, pkt, sizeof(struct packet));
memcpy((char *)dup_pkt->data_ptr, pkt->data_ptr, pkt->data_len);
dup_pkt->need_free = true;
struct metadata *meta = &dup_pkt->meta;
meta->io_ctx = NULL;
// update layers
for (int8_t i = 0; i < pkt->layers_used; i++)
{
dup_pkt->layers[i].hdr_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset;
dup_pkt->layers[i].pld_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
}
// update frag_layer
if (pkt->frag_layer)
{
dup_pkt->frag_layer = &dup_pkt->layers[pkt->frag_layer - pkt->layers];
}
return dup_pkt;
}
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 packet_is_fragment(const struct packet *pkt)
{
if (pkt->frag_layer)
{
return true;
}
else
{
return false;
}
}

94
src/packet/packet_private.h
View File

@@ -15,7 +15,8 @@ extern "C"
#define PACKET_MAX_LAYERS 32
#define PACKET_LOG_ERROR(format, ...) LOG_ERROR("packet", format, ##__VA_ARGS__)
#define PACKET_LOG_DEBUG(format, ...) LOG_DEBUG("packet", format, ##__VA_ARGS__)
#define PACKET_LOG_DEBUG(format, ...) void(0)
//#define PACKET_LOG_DEBUG(format, ...) LOG_DEBUG("packet", format, ##__VA_ARGS__)
enum ldbc_method
{
@@ -26,46 +27,11 @@ enum ldbc_method
LDBC_METHOD_HASH_INNERMOST_EXT_IP = 5,
};
enum packet_direction
enum packet_origin
{
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 *io_ctx;
uint64_t domain;
uint64_t session_id;
enum packet_direction direction;
enum packet_action action;
enum packet_type type;
PACKET_ORIGIN_MARSIO = 0x1,
PACKET_ORIGIN_DUMPFILE = 0x2,
PACKET_ORIGIN_USER = 0x3,
};
struct packet
@@ -77,9 +43,10 @@ struct packet
const char *data_ptr;
uint16_t data_len;
bool need_free;
struct metadata meta;
int need_drop;
void *io_ctx;
enum packet_origin origin;
};
// return innermost payload
@@ -90,50 +57,27 @@ void packet_print(const struct packet *pkt);
// direction 0: I2E
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);
/******************************************************************************
* Utils
******************************************************************************/
// 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_origin(struct packet *pkt, enum packet_origin origin);
enum packet_origin packet_get_origin(const struct packet *pkt);
void packet_set_io_ctx(struct packet *pkt, void *ctx);
void *packet_get_io_ctx(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);
int packet_is_fragment(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);
void packet_set_domain(struct packet *pkt, uint64_t domain);
uint64_t packet_get_domain(const struct packet *pkt);
bool packet_is_fragment(const struct packet *pkt);
void packet_set_route_ctx(struct packet *pkt, const char *route, int len);
int packet_get_route_ctx(const struct packet *pkt, char *buff, int size); // return len of route ctx
#ifdef __cpluscplus
}

310
src/packet/packet_utils.cpp Normal file
View File

@@ -0,0 +1,310 @@
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "packet_private.h"
#include "marsio.h"
/******************************************************************************
* set and get from struct packet
******************************************************************************/
void packet_set_origin(struct packet *pkt, enum packet_origin origin)
{
pkt->origin = origin;
}
enum packet_origin packet_get_origin(const struct packet *pkt)
{
return pkt->origin;
}
int8_t packet_get_layers(const struct packet *pkt)
{
return pkt->layers_used;
}
const struct packet_layer *packet_get_layer(const struct packet *pkt, int8_t idx)
{
if (idx < 0 || idx >= pkt->layers_used)
{
return NULL;
}
return &pkt->layers[idx];
}
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;
}
const char *packet_get_payload(const struct packet *pkt)
{
if (pkt->layers_used == 0)
{
return NULL;
}
return pkt->layers[pkt->layers_used - 1].pld_ptr;
}
uint16_t packet_get_payload_len(const struct packet *pkt)
{
if (pkt->layers_used == 0)
{
return 0;
}
return pkt->layers[pkt->layers_used - 1].pld_len;
}
int packet_need_drop(const struct packet *pkt)
{
return pkt->need_drop;
}
void packet_set_drop(struct packet *pkt)
{
pkt->need_drop = 1;
}
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;
}
int packet_is_fragment(const struct packet *pkt)
{
return (pkt->frag_layer) ? 1 : 0;
}
struct packet *packet_new(uint16_t pkt_len)
{
struct packet *pkt = (struct packet *)calloc(1, sizeof(struct packet) + pkt_len);
if (pkt == NULL)
{
return NULL;
}
pkt->data_len = pkt_len;
pkt->data_ptr = (const char *)pkt + sizeof(struct packet);
pkt->origin = PACKET_ORIGIN_USER;
return pkt;
}
void packet_free(struct packet *pkt)
{
if (pkt && pkt->origin == PACKET_ORIGIN_USER)
{
free((void *)pkt);
}
}
struct packet *packet_dup(const struct packet *pkt)
{
if (pkt == NULL)
{
return NULL;
}
struct packet *dup_pkt = packet_new(pkt->data_len);
if (dup_pkt == NULL)
{
return NULL;
}
memcpy(dup_pkt, pkt, sizeof(struct packet));
memcpy((char *)dup_pkt->data_ptr, pkt->data_ptr, pkt->data_len);
dup_pkt->origin = PACKET_ORIGIN_USER;
dup_pkt->io_ctx = dup_pkt;
// update layers
for (int8_t i = 0; i < pkt->layers_used; i++)
{
dup_pkt->layers[i].hdr_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset;
dup_pkt->layers[i].pld_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
}
// update frag_layer
if (pkt->frag_layer)
{
dup_pkt->frag_layer = &dup_pkt->layers[pkt->frag_layer - pkt->layers];
}
return dup_pkt;
}
/******************************************************************************
* set and get from mbuff
******************************************************************************/
void packet_set_ctrl(struct packet *pkt)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_set_ctrlbuf(mbuff);
}
}
int packet_is_ctrl(const struct packet *pkt)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
return marsio_buff_is_ctrlbuf(mbuff);
}
else
{
return 0;
}
}
// 1: E2I, 0: I2E
void packet_set_direction(struct packet *pkt, int dir)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_set_metadata(mbuff, MR_BUFF_DIR, &dir, sizeof(dir));
}
}
// 1: E2I, 0: I2E
int packet_get_direction(const struct packet *pkt)
{
int direction = 0;
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_get_metadata(mbuff, MR_BUFF_DIR, &direction, sizeof(direction));
}
return direction;
}
void packet_set_session_id(struct packet *pkt, uint64_t sess_id)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_set_metadata(mbuff, MR_BUFF_SESSION_ID, &sess_id, sizeof(sess_id));
}
}
uint64_t packet_get_session_id(const struct packet *pkt)
{
uint64_t sess_id = 0;
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_get_metadata(mbuff, MR_BUFF_SESSION_ID, &sess_id, sizeof(sess_id));
}
return sess_id;
}
void packet_set_domain(struct packet *pkt, uint64_t domain)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
// TODO
// marsio_buff_set_metadata(mbuff, MR_BUFF_DOMAIN, &domain, sizeof(domain));
}
}
uint64_t packet_get_domain(const struct packet *pkt)
{
uint64_t domain = 0;
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
// TODO
// marsio_buff_get_metadata(mbuff, MR_BUFF_DOMAIN, &domain, sizeof(domain));
}
return domain;
}
void packet_set_route_ctx(struct packet *pkt, const char *route, int len)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_set_metadata(mbuff, MR_BUFF_ROUTE_CTX, (void *)route, len);
}
}
// return len of route ctx
int packet_get_route_ctx(const struct packet *pkt, char *buff, int size)
{
int len = 0;
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
len = marsio_buff_get_metadata(mbuff, MR_BUFF_ROUTE_CTX, buff, size);
}
return len;
}
void packet_set_sid_list(struct packet *pkt, uint16_t *sid, int num)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_set_sid_list(mbuff, sid, num);
}
}
// return number of sid
int packet_get_sid_list(const struct packet *pkt, uint16_t *sid, int num)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
return marsio_buff_get_sid_list(mbuff, sid, num);
}
return 0;
}
void packet_prepend_sid_list(struct packet *pkt, uint16_t *sid, int num)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_prepend_sid_list(mbuff, sid, num);
}
}
void packet_append_sid_list(struct packet *pkt, uint16_t *sid, int num)
{
if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
{
marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
assert(mbuff != NULL);
marsio_buff_append_sid_list(mbuff, sid, num);
}
}

41
src/packet_io/dumpfile_io.cpp
View File

@@ -57,7 +57,17 @@ static void pcap_handle(u_char *user, const struct pcap_pkthdr *h, const u_char
// push packet to queue
struct lock_free_queue *queue = handle->queue[hash % handle->nr_threads];
lock_free_queue_push(queue, pcap_pkt);
while (lock_free_queue_push(queue, pcap_pkt) == -1)
{
if (ATOMIC_READ(&handle->io_thread_need_exit))
{
free(pcap_pkt);
PACKET_IO_LOG_STATE("dumpfile io thread need exit");
pcap_breakloop(handle->pcap);
break;
}
usleep(1000);
}
if (ATOMIC_READ(&handle->io_thread_need_exit))
{
@@ -89,7 +99,7 @@ static int dumpfile_handle(const char *file, void *arg)
return 0;
}
static void *dumpfile_thread_cycle(void *arg)
static void *dumpfile_thread(void *arg)
{
struct dumpfile_io *handle = (struct dumpfile_io *)arg;
@@ -104,7 +114,7 @@ static void *dumpfile_thread_cycle(void *arg)
sleep(1);
}
PACKET_IO_LOG_STATE("dumpfile io thread is exiting");
PACKET_IO_LOG_STATE("dumpfile io thread exit !!!");
ATOMIC_SET(&handle->io_thread_is_runing, 0);
return NULL;
@@ -125,7 +135,7 @@ struct dumpfile_io *dumpfile_io_new(const char *directory, uint8_t nr_threads)
}
handle->nr_threads = nr_threads;
strncpy(handle->directory, directory, strlen(directory));
strncpy(handle->directory, directory, MIN(strlen(directory), sizeof(handle->directory)));
for (uint16_t i = 0; i < handle->nr_threads; i++)
{
@@ -136,7 +146,7 @@ struct dumpfile_io *dumpfile_io_new(const char *directory, uint8_t nr_threads)
goto error_out;
}
}
if (pthread_create(&tid, NULL, dumpfile_thread_cycle, (void *)handle) != 0)
if (pthread_create(&tid, NULL, dumpfile_thread, (void *)handle) != 0)
{
PACKET_IO_LOG_ERROR("unable to create packet io thread");
goto error_out;
@@ -160,8 +170,22 @@ void dumpfile_io_free(struct dumpfile_io *handle)
usleep(1000);
}
struct pcap_pkt *pcap_pkt = NULL;
for (uint16_t i = 0; i < handle->nr_threads; i++)
{
while (1)
{
lock_free_queue_pop(handle->queue[i], (void **)&pcap_pkt);
if (pcap_pkt)
{
free(pcap_pkt);
}
else
{
break;
}
}
lock_free_queue_free(handle->queue[i]);
}
free(handle);
@@ -183,6 +207,7 @@ int dumpfile_io_ingress(struct dumpfile_io *handle, uint16_t thr_idx, struct pac
{
struct lock_free_queue *queue = handle->queue[thr_idx];
struct pcap_pkt *pcap_pkt = NULL;
struct packet *pkt;
int nr_parsed = 0;
for (int i = 0; i < nr_pkts; i++)
@@ -200,12 +225,12 @@ int dumpfile_io_ingress(struct dumpfile_io *handle, uint16_t thr_idx, struct pac
ATOMIC_ADD(&handle->stat.raw_rx_pkts, 1);
ATOMIC_ADD(&handle->stat.raw_rx_bytes, pcap_pkt->len);
struct packet *pkt = &pkts[nr_parsed++];
pkt = &pkts[nr_parsed];
memset(pkt, 0, sizeof(struct packet));
packet_parse(pkt, pcap_pkt->data, pcap_pkt->len);
packet_set_io_ctx(pkt, pcap_pkt);
packet_set_type(pkt, PACKET_TYPE_DATA);
packet_set_action(pkt, PACKET_ACTION_FORWARD);
packet_set_origin(pkt, PACKET_ORIGIN_DUMPFILE);
nr_parsed++;
}
}

15
src/packet_io/lock_free_queue.cpp
View File

@@ -44,12 +44,6 @@ void lock_free_queue_free(struct lock_free_queue *queue)
return;
}
// wait queue is empty
while (queue->head != queue->tail)
{
usleep(1000);
}
if (queue->queue)
{
free(queue->queue);
@@ -59,19 +53,16 @@ void lock_free_queue_free(struct lock_free_queue *queue)
free(queue);
}
void lock_free_queue_push(struct lock_free_queue *queue, void *data)
int lock_free_queue_push(struct lock_free_queue *queue, void *data)
{
uint64_t wait = 1000;
retry:
if (__sync_val_compare_and_swap(&queue->queue[queue->tail], 0, data) != 0)
{
LOCK_FREE_QUEUE_LOG_ERROR("lock free queue is full, retry later");
usleep(wait);
wait *= 2;
goto retry;
return -1;
}
queue->tail = (queue->tail + 1) % queue->size;
return 0;
}
void lock_free_queue_pop(struct lock_free_queue *queue, void **data)

2
src/packet_io/lock_free_queue.h
View File

@@ -16,7 +16,7 @@ struct lock_free_queue;
struct lock_free_queue *lock_free_queue_new(uint32_t size);
void lock_free_queue_free(struct lock_free_queue *queue);
void lock_free_queue_push(struct lock_free_queue *queue, void *data);
int lock_free_queue_push(struct lock_free_queue *queue, void *data);
void lock_free_queue_pop(struct lock_free_queue *queue, void **data);
#ifdef __cpluscplus

14
src/packet_io/marsio_io.cpp
View File

@@ -171,8 +171,16 @@ int marsio_io_ingress(struct marsio_io *handle, uint16_t thr_idx, struct packet
continue;
}
pkt = &pkts[nr_parsed];
memset(pkt, 0, sizeof(struct packet));
packet_parse(pkt, data, len);
packet_set_io_ctx(pkt, mbuff);
packet_set_origin(pkt, PACKET_ORIGIN_MARSIO);
nr_parsed++;
if (marsio_buff_is_ctrlbuf(mbuff))
{
packet_set_ctrl(pkt);
ATOMIC_ADD(&handle->stat.ctrl_rx_pkts, 1);
ATOMIC_ADD(&handle->stat.ctrl_rx_bytes, len);
}
@@ -181,12 +189,6 @@ int marsio_io_ingress(struct marsio_io *handle, uint16_t thr_idx, struct packet
ATOMIC_ADD(&handle->stat.raw_rx_pkts, 1);
ATOMIC_ADD(&handle->stat.raw_rx_bytes, len);
}
pkt = &pkts[nr_parsed];
packet_parse(pkt, data, len);
packet_set_io_ctx(pkt, mbuff);
packet_set_action(pkt, PACKET_ACTION_FORWARD);
nr_parsed++;
}
return nr_parsed;

58
src/plugin/plugin_manager.cpp
View File

@@ -1,3 +1,4 @@
#include <assert.h>
#include "plugin_manager.h"
#include "session_private.h"
@@ -9,18 +10,23 @@ struct plugin_manager
void *plugin_manager_new_ctx(struct session *sess)
{
// TODO
return NULL;
return sess;
}
void plugin_manager_free_ctx(void *ctx)
{
// TODO
struct session *sess = (struct session *)ctx;
char buff[4096] = {0};
session_to_json(sess, buff, sizeof(buff));
PLUGIN_MANAGER_LOG_DEBUG("=> SESSION : %s", buff);
}
struct plugin_manager *plugin_manager_new(void)
{
// TODO
return NULL;
static struct plugin_manager mgr;
return &mgr;
}
void plugin_manager_free(struct plugin_manager *mgr)
@@ -31,30 +37,42 @@ void plugin_manager_free(struct plugin_manager *mgr)
void plugin_manager_dispatch_session(struct plugin_manager *mgr, struct session *sess, struct packet *pkt)
{
// TODO
// current implementation only for testing
PLUGIN_MANAGER_LOG_DEBUG("=> plugin dispatch session: %u %s\n", session_get_id(sess), session_get_tuple_str(sess));
session_dump(sess);
struct tcp_segment *seg;
enum session_state state = session_get_state(sess);
enum session_type type = session_get_type(sess);
PLUGIN_MANAGER_LOG_DEBUG("=> plugin dispatch session: %u %s %s %s", session_get_id(sess), session_get_tuple_str(sess), session_type_to_str(type), session_state_to_str(state));
if (session_get_type(sess) == SESSION_TYPE_TCP)
// session_print(sess);
if (packet_is_ctrl(pkt))
{
// TODO Trigger TCP ALL MSG with (mgr, sess, pkt)
do
{
struct tcp_segment *seg = session_get_tcp_segment(sess);
if (seg == NULL)
{
break;
}
// TODO Trigger TCP Stream MSG with (mgr, sess, seg->data, seg->len)
session_free_tcp_segment(sess, seg);
} while (1);
// trigger ctrl msg with (mgr, sess, pkt)
// dispatch_plugin()
}
else
{
// TODO Trigger UDP MSG
switch (type)
{
case SESSION_TYPE_TCP:
// trigger TCP msg with (mgr, sess, pkt)
// dispatch_plugin()
while ((seg = session_get_tcp_segment(sess)) != NULL)
{
// trigger TCP stream msg with (mgr, sess, seg->data, seg->len)
// dispatch_plugin()
session_free_tcp_segment(sess, seg);
}
break;
case SESSION_TYPE_UDP:
// trigger UDP msg with (mgr, sess, pkt)
// dispatch_plugin()
break;
default:
assert(0);
break;
}
}
}

133
src/session/session.cpp
View File

@@ -410,74 +410,81 @@ static void tcp_flags_to_str(uint8_t flags, char *buffer, size_t len)
}
}
void session_dump(struct session *sess)
int session_to_json(struct session *sess, char *buff, int size)
{
char buffer[1024] = {0};
tuple6_to_str(session_get_tuple(sess), buffer, sizeof(buffer));
memset(buff, 0, size);
char flags[64] = {0};
int used = 0;
printf("session id : %" PRIu64 "\n", session_get_id(sess));
printf("session timestamp : %" PRIu64 " -> %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_START), session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
printf("session tuple : %s (%s)\n", buffer, session_direction_to_str(session_get_tuple_direction(sess)));
printf("session type : %s\n", session_type_to_str(session_get_type(sess)));
printf("session state : %s\n", session_state_to_str(session_get_state(sess)));
printf("session closing reason : %s\n", closing_reason_to_str(session_get_closing_reason(sess)));
printf("session dup traffic : %d\n", session_has_dup_traffic(sess));
printf("session C2S first packet : %p\n", session_get_1st_packet(sess, SESSION_DIRECTION_C2S));
printf("session S2C first packet : %p\n", session_get_1st_packet(sess, SESSION_DIRECTION_S2C));
printf("session current packet : %p (%s)\n", session_get_current_packet(sess), session_direction_to_str(session_get_current_direction(sess)));
used += snprintf(buff + used, size - used, "{");
used += snprintf(buff + used, size - used, "\"id\":%" PRIu64 ",", session_get_id(sess));
used += snprintf(buff + used, size - used, "\"start_timestamp\":%" PRIu64 ",", session_get_timestamp(sess, SESSION_TIMESTAMP_START));
used += snprintf(buff + used, size - used, "\"last_timestamp\":%" PRIu64 ",", session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
used += snprintf(buff + used, size - used, "\"tuple\":\"%s\",", session_get_tuple_str(sess));
used += snprintf(buff + used, size - used, "\"type\":\"%s\",", session_type_to_str(session_get_type(sess)));
used += snprintf(buff + used, size - used, "\"state\":\"%s\",", session_state_to_str(session_get_state(sess)));
used += snprintf(buff + used, size - used, "\"closing_reason\":\"%s\",", closing_reason_to_str(session_get_closing_reason(sess)));
used += snprintf(buff + used, size - used, "\"dup_traffic\":%d,", session_has_dup_traffic(sess));
used += snprintf(buff + used, size - used, "\"current_packet\":\"%p\",", session_get_current_packet(sess));
const char *str[] = {"c2s", "s2c"};
enum session_direction dir[] = {SESSION_DIRECTION_C2S, SESSION_DIRECTION_S2C};
for (int i = 0; i < 2; i++)
{
if (session_get_type(sess) == SESSION_TYPE_TCP)
{
memset(buffer, 0, sizeof(buffer));
tcp_flags_to_str(sess->tcp_halfs[SESSION_DIRECTION_C2S].flags, buffer, sizeof(buffer));
printf("TCP C2S half: seq: %u, ack: %u, flags: %s\n", sess->tcp_halfs[SESSION_DIRECTION_C2S].seq, sess->tcp_halfs[SESSION_DIRECTION_C2S].ack, buffer);
used += snprintf(buff + used, size - used, "\"%s_tcp_last_seq\":%u,", str[i], sess->tcp_halfs[dir[i]].seq);
used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[dir[i]].ack);
memset(flags, 0, sizeof(flags));
tcp_flags_to_str(sess->tcp_halfs[dir[i]].flags, flags, sizeof(flags));
used += snprintf(buff + used, size - used, "\"%s_tcp_flags\":\"%s\",", str[i], flags);
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_RX));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_RX));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_EXPIRED));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_EXPIRED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_OVERLAP));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_OVERLAP));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_NOSPACE));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_NOSPACE));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_INORDER));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_INORDER));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_REORDERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_REORDERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_BUFFERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_BUFFERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segs_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_RELEASED));
used += snprintf(buff + used, size - used, "\"%s_tcp_plds_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_RELEASED));
}
memset(buffer, 0, sizeof(buffer));
tcp_flags_to_str(sess->tcp_halfs[SESSION_DIRECTION_S2C].flags, buffer, sizeof(buffer));
printf("TCP S2C half: seq: %u, ack: %u, flags: %s\n", sess->tcp_halfs[SESSION_DIRECTION_S2C].seq, sess->tcp_halfs[SESSION_DIRECTION_S2C].ack, buffer);
}
// exdata
printf("session exdata:\n");
for (uint8_t i = 0; i < g_ex_manager.count; i++)
used += snprintf(buff + used, size - used, "\"%s_1st_pkt\":\"%p\",", str[i], session_get_1st_packet(sess, dir[i]));
used += snprintf(buff + used, size - used, "\"%s_raw_pkts_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PKTS_RX));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_RX));
used += snprintf(buff + used, size - used, "\"%s_raw_pkts_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PKTS_TX));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_TX));
used += snprintf(buff + used, size - used, "\"%s_raw_pkts_drop\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PKTS_DROP));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_drop\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_DROP));
used += snprintf(buff + used, size - used, "\"%s_dup_pkts_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUP_PKTS_BYPASS));
used += snprintf(buff + used, size - used, "\"%s_dup_bytes_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUP_BYTES_BYPASS));
used += snprintf(buff + used, size - used, "\"%s_ctrl_pkts_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_PKTS_RX));
used += snprintf(buff + used, size - used, "\"%s_ctrl_bytes_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_BYTES_RX));
used += snprintf(buff + used, size - used, "\"%s_ctrl_pkts_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_PKTS_TX));
used += snprintf(buff + used, size - used, "\"%s_ctrl_bytes_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_BYTES_TX));
used += snprintf(buff + used, size - used, "\"%s_ctrl_pkts_drop\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_PKTS_DROP));
used += snprintf(buff + used, size - used, "\"%s_ctrl_bytes_drop\":%" PRIu64 "", str[i], session_get_stat(sess, dir[i], STAT_CTRL_BYTES_DROP));
if (i == 0)
{
printf(" idx: %d, key: %s, data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
used += snprintf(buff + used, size - used, ",");
}
// stats
printf("session stats:\n");
printf("+------------------------------------------------+\n");
printf("| %-20s | %-10s | %-10s |\n", "stat", "C2S", "S2C");
printf("+------------------------------------------------+\n");
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_RX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_RX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_TX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_TX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_DROP));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_DROP));
printf("+------------------------------------------------+\n");
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "DUP_PKTS_BYPASS", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_DUP_PKTS_BYPASS), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_DUP_PKTS_BYPASS));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "DUP_BYTES_BYPASS", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_DUP_BYTES_BYPASS), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_DUP_BYTES_BYPASS));
printf("+------------------------------------------------+\n");
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_RX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_RX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_TX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_TX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_DROP));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_DROP));
printf("+------------------------------------------------+\n");
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RX));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_EXPIRED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_EXPIRED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_EXPIRED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_EXPIRED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_EXPIRED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_EXPIRED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_OVERLAP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_OVERLAP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_OVERLAP));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_OVERLAP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_OVERLAP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_OVERLAP));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_NOSPACE", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_NOSPACE), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_NOSPACE));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_NOSPACE", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_NOSPACE), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_NOSPACE));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_INORDER", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_INORDER), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_INORDER));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_INORDER", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_INORDER), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_INORDER));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_REORDERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_REORDERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_REORDERED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_REORDERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_REORDERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_REORDERED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_BUFFERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_BUFFERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_BUFFERED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_BUFFERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_BUFFERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_BUFFERED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_RELEASED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RELEASED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RELEASED));
printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_RELEASED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RELEASED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RELEASED));
printf("+------------------------------------------------+\n");
}
used += snprintf(buff + used, size - used, "}");
return used;
}
void session_print(struct session *sess)
{
char buff[4096];
session_to_json(sess, buff, sizeof(buff));
printf("%s\n", buff);
}

3
src/session/session_private.h
View File

@@ -118,7 +118,8 @@ void session_free_all_ex_data(struct session *sess);
* debug
******************************************************************************/
void session_dump(struct session *sess);
void session_print(struct session *sess);
int session_to_json(struct session *sess, char *buff, int size);
#ifdef __cpluscplus
}

4
src/session/test/gtest_sess_mgr_tcp_reassembly.cpp
View File

@@ -235,7 +235,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -324,7 +324,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

22
src/session/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -132,7 +132,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -148,7 +148,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -220,7 +220,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -236,7 +236,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -308,7 +308,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -324,7 +324,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -373,7 +373,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -438,7 +438,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -454,7 +454,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -519,7 +519,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -535,7 +535,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

32
src/session/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -91,7 +91,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -108,7 +108,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -170,7 +170,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -187,7 +187,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -260,7 +260,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -277,7 +277,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -361,7 +361,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -378,7 +378,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -458,7 +458,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -475,7 +475,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -556,7 +556,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -573,7 +573,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -646,7 +646,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -663,7 +663,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -736,7 +736,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -753,7 +753,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

2
src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -412,7 +412,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

8
src/session/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -101,7 +101,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -118,7 +118,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -191,7 +191,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -208,7 +208,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

30
src/session/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -113,7 +113,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -129,7 +129,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -209,7 +209,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -225,7 +225,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -305,7 +305,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -321,7 +321,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -379,7 +379,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -452,7 +452,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -469,7 +469,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -553,7 +553,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -570,7 +570,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -643,7 +643,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -659,7 +659,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -732,7 +732,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -748,7 +748,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

4
src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -116,7 +116,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -133,7 +133,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

8
src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -91,7 +91,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -108,7 +108,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -171,7 +171,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
session_dump(sess);
session_print(sess);
// check stat
session_manager_print_stat(mgr);
@@ -189,7 +189,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

2
src/session/test/gtest_timeout_tcp_data.cpp
View File

@@ -82,7 +82,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

2
src/session/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -72,7 +72,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

2
src/session/test/gtest_timeout_tcp_init.cpp
View File

@@ -72,7 +72,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

4
src/session/test/gtest_timeout_udp_data.cpp
View File

@@ -71,7 +71,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);
@@ -117,7 +117,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
session_print(sess);
// free session
session_manager_free_session(mgr, sess);

45
src/stellar/stellar.cpp
View File

@@ -59,19 +59,19 @@ static void signal_handler(int signo)
{
if (signo == SIGINT)
{
STELLAR_LOG_STATE("SIGINT received, exit !!!");
STELLAR_LOG_STATE("SIGINT received, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
if (signo == SIGQUIT)
{
STELLAR_LOG_STATE("SIGQUIT received, exit !!!");
STELLAR_LOG_STATE("SIGQUIT received, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
if (signo == SIGTERM)
{
STELLAR_LOG_STATE("SIGTERM received, exit !!!");
STELLAR_LOG_STATE("SIGTERM received, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
@@ -84,22 +84,22 @@ static void signal_handler(int signo)
static void execute_packet_action(struct packet_io *packet_io, struct session *sess, struct packet *pkt, uint16_t thr_idx)
{
enum packet_action action = packet_get_action(pkt);
enum packet_type type = packet_get_type(pkt);
int is_ctrl = packet_is_ctrl(pkt);
int need_drop = packet_need_drop(pkt);
if (sess)
if (sess != NULL)
{
enum session_stat stat_pkt;
enum session_stat stat_byte;
if (action == PACKET_ACTION_DROP)
if (need_drop)
{
stat_pkt = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_PKTS_DROP : STAT_RAW_PKTS_DROP;
stat_byte = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_BYTES_DROP : STAT_RAW_BYTES_DROP;
stat_pkt = is_ctrl ? STAT_CTRL_PKTS_DROP : STAT_RAW_PKTS_DROP;
stat_byte = is_ctrl ? STAT_CTRL_BYTES_DROP : STAT_RAW_BYTES_DROP;
}
else
{
stat_pkt = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_PKTS_TX : STAT_RAW_PKTS_TX;
stat_byte = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_BYTES_TX : STAT_RAW_BYTES_TX;
stat_pkt = is_ctrl ? STAT_CTRL_PKTS_TX : STAT_RAW_PKTS_TX;
stat_byte = is_ctrl ? STAT_CTRL_BYTES_TX : STAT_RAW_BYTES_TX;
}
session_inc_stat(sess, session_get_current_direction(sess), stat_pkt, 1);
@@ -108,7 +108,7 @@ static void execute_packet_action(struct packet_io *packet_io, struct session *s
session_set_current_direction(sess, SESSION_DIRECTION_NONE);
}
if (action == PACKET_ACTION_DROP)
if (need_drop)
{
packet_io_drop(packet_io, thr_idx, pkt, 1);
}
@@ -168,6 +168,7 @@ static void *work_thread(void *arg)
for (int i = 0; i < nr_recv; i++)
{
sess = NULL;
pkt = &packets[i];
plugin_manager_dispatch_packet(plug_mgr, pkt);
@@ -237,7 +238,7 @@ static void *work_thread(void *arg)
}
ATOMIC_SET(&thr_ctx->is_runing, 0);
STELLAR_LOG_STATE("worker thread %d stop", thr_idx);
STELLAR_LOG_STATE("worker thread %d exit !!!", thr_idx);
return NULL;
}
@@ -315,7 +316,9 @@ static void stellar_thread_join(struct stellar_runtime *ctx, uint8_t nr_threads)
int main(int argc, char **argv)
{
uint8_t nr_threads;
memset(runtime, 0, sizeof(struct stellar_runtime));
memset(config, 0, sizeof(struct stellar_config));
timestamp_update();
signal(SIGINT, signal_handler);
@@ -326,31 +329,31 @@ int main(int argc, char **argv)
if (log_init(log_config_file) != 0)
{
STELLAR_LOG_ERROR("unable to init log");
return -1;
goto error_out;
}
STELLAR_LOG_STATE("Start Stellar (version: %s)\n %s", __stellar_version, logo_str);
STELLAR_LOG_STATE("start stellar (version: %s)\n %s", __stellar_version, logo_str);
if (stellar_config_load(stellar_config_file, config) != 0)
{
STELLAR_LOG_ERROR("unable to load config file");
return -1;
goto error_out;
}
stellar_config_print(config);
if (id_generator_init(config->dev_opts.base, config->dev_opts.offset) != 0)
{
STELLAR_LOG_ERROR("unable to init id generator");
return -1;
goto error_out;
}
runtime->plug_mgr = plugin_manager_new();
if (runtime->plug_mgr == NULL)
{
STELLAR_LOG_ERROR("unable to create plugin manager");
return -1;
goto error_out;
}
uint8_t nr_threads = config->io_opts.nr_threads;
nr_threads = config->io_opts.nr_threads;
runtime->packet_io = packet_io_new(&config->io_opts);
if (runtime->packet_io == NULL)
{
@@ -373,7 +376,7 @@ int main(int argc, char **argv)
while (!ATOMIC_READ(&runtime->need_exit))
{
timestamp_update();
sleep(1);
usleep(5 * 1000);
}
error_out:
@@ -381,7 +384,7 @@ error_out:
stellar_thread_clean(runtime, nr_threads);
packet_io_free(runtime->packet_io);
plugin_manager_free(runtime->plug_mgr);
STELLAR_LOG_STATE("stellar exit !!!\n");
log_free();
return 0;

2
src/tcp_reassembly/tcp_reassembly.cpp
View File

@@ -130,7 +130,7 @@ struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *assembler)
}
uint64_t min_id = UINT64_MAX;
struct tcp_segment_private *oldest;
struct tcp_segment_private *oldest = NULL;
while (node)
{
struct tcp_segment_private *p = container_of(node, struct tcp_segment_private, node);