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

refactor: move packet_ldbc_hash to packet.cpp

Browse Source
This commit is contained in:
luwenpeng
2024-08-16 17:07:52 +08:00
parent 60a4666427
commit 839e848473
8 changed files with 144 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/packet/CMakeLists.txt
View File

@@ -4,7 +4,6 @@ add_library(packet
packet_builder.cpp
packet_filter.cpp
packet_dump.cpp
packet_ldbc.cpp
checksum.cpp)
target_include_directories(packet PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/deps/uthash)

125
src/packet/packet.cpp
View File

@@ -2,6 +2,7 @@
#include "log.h"
#include "tuple.h"
#include "uthash.h"
#include "packet_helper.h"
#include "packet_private.h"
@@ -455,7 +456,7 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
}
/******************************************************************************
* layer layer
* layer uitls
******************************************************************************/
int packet_get_layer_count(const struct packet *pkt)
@@ -692,6 +693,128 @@ int packet_get_tunnel_by_idx(const struct packet *pkt, int idx, struct tunnel *o
return -1;
}
/******************************************************************************
* load balance uitls
******************************************************************************/
uint64_t packet_ldbc_hash(const struct packet *pkt, enum packet_load_balance_method method, enum packet_direction direction)
{
uint64_t temp = 0;
uint64_t hash_value = 1;
int inner_addr_len = 0;
int outer_addr_len = 0;
const char *inner_src_addr = NULL;
const char *inner_dst_addr = NULL;
const char *outer_src_addr = NULL;
const char *outer_dst_addr = NULL;
struct tuple2 inner_addr;
struct tuple2 outer_addr;
if (pkt == NULL)
{
return hash_value;
}
if (packet_get_innermost_tuple2(pkt, &inner_addr) == -1)
{
return hash_value;
}
if (packet_get_outermost_tuple2(pkt, &outer_addr) == -1)
{
return hash_value;
}
if (inner_addr.addr_family == AF_INET)
{
inner_src_addr = (const char *)&inner_addr.src_addr.v4;
inner_dst_addr = (const char *)&inner_addr.dst_addr.v4;
inner_addr_len = sizeof(struct in_addr);
}
else
{
inner_src_addr = (const char *)&inner_addr.src_addr.v6;
inner_dst_addr = (const char *)&inner_addr.dst_addr.v6;
inner_addr_len = sizeof(struct in6_addr);
}
if (outer_addr.addr_family == AF_INET)
{
outer_src_addr = (const char *)&outer_addr.src_addr.v4;
outer_dst_addr = (const char *)&outer_addr.dst_addr.v4;
outer_addr_len = sizeof(struct in_addr);
}
else
{
outer_src_addr = (const char *)&outer_addr.src_addr.v6;
outer_dst_addr = (const char *)&outer_addr.dst_addr.v6;
outer_addr_len = sizeof(struct in6_addr);
}
switch (method)
{
case PKT_LDBC_METH_OUTERMOST_INT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
}
break;
case PKT_LDBC_METH_OUTERMOST_EXT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
}
break;
case PKT_LDBC_METH_OUTERMOST_INT_EXT_IP:
HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
HASH_VALUE(outer_dst_addr, outer_addr_len, temp);
hash_value = hash_value ^ temp;
break;
case PKT_LDBC_METH_INNERMOST_INT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
}
break;
case PKT_LDBC_METH_INNERMOST_EXT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
}
break;
default:
return hash_value;
}
return hash_value;
}
/******************************************************************************
* other uitls
******************************************************************************/

14
src/packet/packet_builder.h
View File

@@ -1,14 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdint.h>
void append_fingerprint_to_build_packet();
#ifdef __cplusplus
}
#endif

121
src/packet/packet_ldbc.cpp
View File

@@ -1,121 +0,0 @@
#include "tuple.h"
#include "uthash.h"
#include "packet_ldbc.h"
#include "packet_private.h"
uint64_t packet_ldbc_hash(const struct packet *pkt, enum load_balance ldbc, enum packet_direction direction)
{
uint64_t temp = 0;
uint64_t hash_value = 1;
int inner_addr_len = 0;
int outer_addr_len = 0;
const char *inner_src_addr = NULL;
const char *inner_dst_addr = NULL;
const char *outer_src_addr = NULL;
const char *outer_dst_addr = NULL;
struct tuple2 inner_addr;
struct tuple2 outer_addr;
if (pkt == NULL)
{
return hash_value;
}
if (packet_get_innermost_tuple2(pkt, &inner_addr) == -1)
{
return hash_value;
}
if (packet_get_outermost_tuple2(pkt, &outer_addr) == -1)
{
return hash_value;
}
if (inner_addr.addr_family == AF_INET)
{
inner_src_addr = (const char *)&inner_addr.src_addr.v4;
inner_dst_addr = (const char *)&inner_addr.dst_addr.v4;
inner_addr_len = sizeof(struct in_addr);
}
else
{
inner_src_addr = (const char *)&inner_addr.src_addr.v6;
inner_dst_addr = (const char *)&inner_addr.dst_addr.v6;
inner_addr_len = sizeof(struct in6_addr);
}
if (outer_addr.addr_family == AF_INET)
{
outer_src_addr = (const char *)&outer_addr.src_addr.v4;
outer_dst_addr = (const char *)&outer_addr.dst_addr.v4;
outer_addr_len = sizeof(struct in_addr);
}
else
{
outer_src_addr = (const char *)&outer_addr.src_addr.v6;
outer_dst_addr = (const char *)&outer_addr.dst_addr.v6;
outer_addr_len = sizeof(struct in6_addr);
}
switch (ldbc)
{
case LDBC_HASH_OUTERMOST_INT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
}
break;
case LDBC_HASH_OUTERMOST_EXT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
}
break;
case LDBC_HASH_OUTERMOST_INT_EXT_IP:
HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
HASH_VALUE(outer_dst_addr, outer_addr_len, temp);
hash_value = hash_value ^ temp;
break;
case LDBC_HASH_INNERMOST_INT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
}
break;
case LDBC_HASH_INNERMOST_EXT_IP:
if (direction == PACKET_DIRECTION_INCOMING)
{
// direction 1: E2I
HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
}
else
{
// direction 0: I2E
HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
}
break;
default:
return hash_value;
}
return hash_value;
}

25
src/packet/packet_ldbc.h
View File

@@ -1,25 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdint.h>
#include "stellar/packet.h"
enum load_balance
{
LDBC_HASH_OUTERMOST_INT_IP = 1,
LDBC_HASH_OUTERMOST_EXT_IP = 2,
LDBC_HASH_OUTERMOST_INT_EXT_IP = 3,
LDBC_HASH_INNERMOST_INT_IP = 4,
LDBC_HASH_INNERMOST_EXT_IP = 5,
};
uint64_t packet_ldbc_hash(const struct packet *pkt, enum load_balance ldbc, enum packet_direction direction);
#ifdef __cplusplus
}
#endif

15
src/packet/packet_private.h
View File

@@ -59,6 +59,15 @@ struct packet
struct metadata meta;
};
enum packet_load_balance_method
{
PKT_LDBC_METH_OUTERMOST_INT_IP = 1,
PKT_LDBC_METH_OUTERMOST_EXT_IP = 2,
PKT_LDBC_METH_OUTERMOST_INT_EXT_IP = 3,
PKT_LDBC_METH_INNERMOST_INT_IP = 4,
PKT_LDBC_METH_INNERMOST_EXT_IP = 5,
};
/******************************************************************************
* metadata utils
******************************************************************************/
@@ -116,6 +125,12 @@ const struct raw_layer *packet_get_raw_layer(const struct packet *pkt, int idx);
const struct raw_layer *packet_get_innermost_raw_layer(const struct packet *pkt, enum layer_proto proto);
const struct raw_layer *packet_get_outermost_raw_layer(const struct packet *pkt, enum layer_proto proto);
/******************************************************************************
* load balance uitls
******************************************************************************/
uint64_t packet_ldbc_hash(const struct packet *pkt, enum packet_load_balance_method method, enum packet_direction direction);
/******************************************************************************
* other uitls
******************************************************************************/

9
src/packet/test/gtest_packet_ldbc.cpp
View File

@@ -2,7 +2,6 @@
#include <arpa/inet.h>
#include "packet_private.h"
#include "packet_ldbc.h"
#include "packet_parser.h"
#include "packet_dump.h"
@@ -82,11 +81,11 @@ TEST(PACKET_LDBC, HASH_VALUE)
// buffer: "2001:da8:200:900e:200:5efe:d24d:58a3 0 2600:140e:6::1702:1058 0"
// buffer: "210.77.88.163 0 59.66.4.50 0"
EXPECT_TRUE(packet_ldbc_hash(&handler, LDBC_HASH_OUTERMOST_INT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, LDBC_HASH_OUTERMOST_EXT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, LDBC_HASH_OUTERMOST_EXT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, LDBC_HASH_OUTERMOST_INT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, PKT_LDBC_METH_OUTERMOST_INT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, PKT_LDBC_METH_OUTERMOST_EXT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, PKT_LDBC_METH_OUTERMOST_EXT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, PKT_LDBC_METH_OUTERMOST_INT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, LDBC_HASH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, LDBC_HASH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, LDBC_HASH_INNERMOST_INT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, LDBC_HASH_INNERMOST_EXT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, PKT_LDBC_METH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, PKT_LDBC_METH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_OUTGOING));
EXPECT_TRUE(packet_ldbc_hash(&handler, PKT_LDBC_METH_INNERMOST_INT_IP, PACKET_DIRECTION_INCOMING) == packet_ldbc_hash(&handler, PKT_LDBC_METH_INNERMOST_EXT_IP, PACKET_DIRECTION_OUTGOING));
}
#endif

3
src/packet_io/dumpfile_io.cpp
View File

@@ -14,7 +14,6 @@
#include "utils.h"
#include "dumpfile_io.h"
#include "packet_private.h"
#include "packet_ldbc.h"
#include "packet_parser.h"
#include "packet_dump.h"
#include "lock_free_queue.h"
@@ -130,7 +129,7 @@ static void pcap_packet_handler(u_char *user, const struct pcap_pkthdr *h, const
struct packet pkt;
memset(&pkt, 0, sizeof(struct packet));
packet_parse(&pkt, pcap_pkt->data, pcap_pkt->len);
uint64_t hash = packet_ldbc_hash(&pkt, LDBC_HASH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_OUTGOING);
uint64_t hash = packet_ldbc_hash(&pkt, PKT_LDBC_METH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_OUTGOING);
// push packet to queue
struct lock_free_queue *queue = handle->queue[hash % handle->nr_threads];