gfwleak/tango-tsg-service-chaining-engine
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TSG-13347 Steering Service开发流表

Browse Source
This commit is contained in:
luwenpeng
2023-01-10 16:30:34 +08:00
parent 4639d9ceaa
commit fcc99918fd
13 changed files with 466 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -56,7 +56,7 @@ add_custom_target("install-program" COMMAND ${CMAKE_COMMAND} ARGS -DCOMPONENT=Pr
add_custom_target("install-profile" COMMAND ${CMAKE_COMMAND} ARGS -DCOMPONENT=Profile -P cmake_install.cmake) add_custom_target("install-profile" COMMAND ${CMAKE_COMMAND} ARGS -DCOMPONENT=Profile -P cmake_install.cmake)
enable_testing() enable_testing()
#add_subdirectory(vendor) add_subdirectory(vendor)
add_subdirectory(common) add_subdirectory(common)
add_subdirectory(platform) add_subdirectory(platform)
#add_subdirectory(script) #add_subdirectory(script)

4
common/CMakeLists.txt
View File

@@ -1,3 +1,5 @@
add_library(common src/conntable.cpp src/bfd.cpp) add_library(common src/stream_addr.cpp src/stream_table.cpp src/bfd.cpp)
target_include_directories(common PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include) target_include_directories(common PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
add_subdirectory(test)

30
common/include/conntable.h
View File

@@ -1,30 +0,0 @@
#ifndef _CONNTABLE_H
#define _CONNTABLE_H
#ifdef __cpluscplus
extern "C"
{
#endif
#include <stdint.h>
struct tuple4
{
/* data */
};
struct conntable;
struct conntable *conntable_create();
void conntable_destory(struct conntable *table);
void conntable_add(struct conntable *table, uint64_t streamid, void *val);
void conntable_del(struct conntable *table, uint64_t streamid);
void *conntable_search_by_streamid(struct conntable *table, uint64_t streamid);
void *conntable_search_by_tuple4(struct conntable *table, struct tuple4 *tuplekey);
#ifdef __cpluscplus
}
#endif
#endif

49
common/include/stream_addr.h Normal file
View File

@@ -0,0 +1,49 @@
#ifndef _STREAM_ADDR_H
#define _STREAM_ADDR_H
#ifdef __cpluscplus
extern "C"
{
#endif
#include <netinet/in.h>
enum stream_addr_type
{
STREAM_ADDR_TYPE_V4,
STREAM_ADDR_TYPE_V6,
};
struct stream_addr_v4
{
struct in_addr src_addr; /* network order */
struct in_addr dst_addr; /* network order */
in_port_t src_port; /* network order */
in_port_t dst_port; /* network order */
};
struct stream_addr_v6
{
struct in6_addr src_addr; /* network order */
struct in6_addr dst_addr; /* network order */
in_port_t src_port; /* network order */
in_port_t dst_port; /* network order */
};
struct stream_addr
{
enum stream_addr_type addr_type;
union
{
struct stream_addr_v4 addr_v4;
struct stream_addr_v6 addr_v6;
};
};
char *stream_addr_to_str(const struct stream_addr *addr);
#ifdef __cpluscplus
}
#endif
#endif

50
common/include/stream_table.h Normal file
View File

@@ -0,0 +1,50 @@
#ifndef _STREAM_TABLE_H
#define _STREAM_TABLE_H
#ifdef __cpluscplus
extern "C"
{
#endif
#include <stdint.h>
#include <sys/types.h>
#include "uthash.h"
#include "stream_addr.h"
// Note: key_streamaddr must be initialized by memset(0) before use !!!
typedef void fn_free_cb(void *args);
struct stream_node
{
uint64_t key_streamid; /* first key */
struct stream_addr key_streamaddr; /* second key */
void *val_data;
fn_free_cb *val_freecb;
UT_hash_handle hh1; /* handle for first hash table */
UT_hash_handle hh2; /* handle for second hash table */
};
struct stream_table;
struct stream_table *stream_table_create();
void stream_table_destory(struct stream_table *table);
// key_streamaddr : deep copy
// val_data : shallow copy (malloc by user, free by val_freecb)
int stream_table_insert(struct stream_table *table, uint64_t key_streamid, const struct stream_addr *key_streamaddr, void *val_data, const fn_free_cb *val_freecb);
int stream_table_delete_by_streamid(struct stream_table *table, uint64_t key_streamid);
int stream_table_delete_by_streamaddr(struct stream_table *table, const struct stream_addr *key_streamaddr);
struct stream_node *stream_table_search_by_streamid(struct stream_table *table, uint64_t key_streamid);
struct stream_node *stream_table_search_by_streamaddr(struct stream_table *table, const struct stream_addr *key_streamaddr);
#ifdef __cpluscplus
}
#endif
#endif

30
common/src/conntable.cpp
View File

@@ -1,30 +0,0 @@
#include "conntable.h"
#include "uthash.h"
#include "log.h"
struct conntable *conntable_create()
{
return NULL;
}
void conntable_destory(struct conntable *table)
{
}
void conntable_add(struct conntable *table, uint64_t streamid, void *val)
{
}
void conntable_del(struct conntable *table, uint64_t streamid)
{
}
void *conntable_search_by_streamid(struct conntable *table, uint64_t streamid)
{
return NULL;
}
void *conntable_search_by_tuple4(struct conntable *table, struct tuple4 *tuplekey)
{
return NULL;
}

33
common/src/stream_addr.cpp Normal file
View File

@@ -0,0 +1,33 @@
#include <stdio.h>
#include <arpa/inet.h>
#include "stream_addr.h"
char *stream_addr_to_str(const struct stream_addr *addr)
{
char *str_ret = NULL;
if (addr->addr_type == STREAM_ADDR_TYPE_V4)
{
char src_addr[INET_ADDRSTRLEN] = {0};
char dst_addr[INET_ADDRSTRLEN] = {0};
uint16_t src_port = ntohs((uint16_t)addr->addr_v4.src_port);
uint16_t dst_port = ntohs((uint16_t)addr->addr_v4.dst_port);
inet_ntop(AF_INET, &addr->addr_v4.src_addr, src_addr, sizeof(src_addr));
inet_ntop(AF_INET, &addr->addr_v4.dst_addr, dst_addr, sizeof(dst_addr));
asprintf(&str_ret, "%s %u %s %u", src_addr, src_port, dst_addr, dst_port);
}
if (addr->addr_type == STREAM_ADDR_TYPE_V6)
{
char src_addr[INET6_ADDRSTRLEN] = {0};
char dst_addr[INET6_ADDRSTRLEN] = {0};
uint16_t src_port = ntohs((uint16_t)addr->addr_v6.src_port);
uint16_t dst_port = ntohs((uint16_t)addr->addr_v6.dst_port);
inet_ntop(AF_INET6, &addr->addr_v6.src_addr, src_addr, sizeof(src_addr));
inet_ntop(AF_INET6, &addr->addr_v6.dst_addr, dst_addr, sizeof(dst_addr));
asprintf(&str_ret, "%s %u %s %u", src_addr, src_port, dst_addr, dst_port);
}
return str_ret;
}

161
common/src/stream_table.cpp Normal file
View File

@@ -0,0 +1,161 @@
#include <assert.h>
#include "stream_table.h"
#include "log.h"
struct stream_table
{
struct stream_node *streamid_root;
struct stream_node *streamaddr_root;
};
// Note: key_streamaddr must be initialized by memset(0) before use !!!
struct stream_table *stream_table_create()
{
struct stream_table *table = (struct stream_table *)calloc(1, sizeof(struct stream_table));
assert(table);
return table;
}
void stream_table_destory(struct stream_table *table)
{
if (table)
{
struct stream_node *temp = NULL;
struct stream_node *node = NULL;
HASH_ITER(hh1, table->streamid_root, node, temp)
{
HASH_DELETE(hh1, table->streamid_root, node);
HASH_DELETE(hh2, table->streamaddr_root, node);
if (node->val_freecb && node->val_data)
{
node->val_freecb(node->val_data);
}
free(node);
node = NULL;
}
free(table);
table = NULL;
}
}
// key_streamaddr : deep copy
// val_data : shallow copy (malloc by user, free by val_freecb)
int stream_table_insert(struct stream_table *table, uint64_t key_streamid, const struct stream_addr *key_streamaddr, void *val_data, const fn_free_cb *val_freecb)
{
struct stream_node *temp = NULL;
HASH_FIND(hh1, table->streamid_root, &key_streamid, sizeof(key_streamid), temp);
if (temp)
{
LOG_DEBUG("stream table insert: key %lu exists", key_streamid);
return -1;
}
temp = (struct stream_node *)calloc(1, sizeof(struct stream_node));
assert(temp);
temp->key_streamid = key_streamid;
memcpy(&temp->key_streamaddr, key_streamaddr, sizeof(struct stream_addr));
temp->val_data = val_data;
temp->val_freecb = val_freecb;
HASH_ADD(hh1, table->streamid_root, key_streamid, sizeof(temp->key_streamid), temp);
HASH_ADD(hh2, table->streamaddr_root, key_streamaddr, sizeof(temp->key_streamaddr), temp);
LOG_DEBUG("stream table insert: key %lu success", key_streamid);
return 0;
}
int stream_table_delete_by_streamid(struct stream_table *table, uint64_t key_streamid)
{
struct stream_node *temp = NULL;
HASH_FIND(hh1, table->streamid_root, &key_streamid, sizeof(key_streamid), temp);
if (!temp)
{
LOG_DEBUG("stream table delete: key %lu not exists", key_streamid);
return -1;
}
HASH_DELETE(hh1, table->streamid_root, temp);
HASH_DELETE(hh2, table->streamaddr_root, temp);
if (temp->val_freecb && temp->val_data)
{
temp->val_freecb(temp->val_data);
}
free(temp);
temp = NULL;
LOG_DEBUG("stream table delete: key %lu success", key_streamid);
return 0;
}
int stream_table_delete_by_streamaddr(struct stream_table *table, const struct stream_addr *key_streamaddr)
{
struct stream_node *temp = NULL;
char *addr_str = stream_addr_to_str(key_streamaddr);
HASH_FIND(hh2, table->streamaddr_root, key_streamaddr, sizeof(*key_streamaddr), temp);
if (!temp)
{
LOG_DEBUG("stream table delete: key %s not exists", addr_str);
free(addr_str);
return -1;
}
HASH_DELETE(hh1, table->streamid_root, temp);
HASH_DELETE(hh2, table->streamaddr_root, temp);
if (temp->val_freecb && temp->val_data)
{
temp->val_freecb(temp->val_data);
}
free(temp);
temp = NULL;
LOG_DEBUG("stream table delete: key %s success", addr_str);
free(addr_str);
addr_str = NULL;
return 0;
}
struct stream_node *stream_table_search_by_streamid(struct stream_table *table, uint64_t key_streamid)
{
struct stream_node *temp = NULL;
HASH_FIND(hh1, table->streamid_root, &key_streamid, sizeof(key_streamid), temp);
if (!temp)
{
LOG_DEBUG("stream table search: key %lu not exists", key_streamid);
return NULL;
}
LOG_DEBUG("stream table search: key %lu success", key_streamid);
return temp;
}
struct stream_node *stream_table_search_by_streamaddr(struct stream_table *table, const struct stream_addr *key_streamaddr)
{
struct stream_node *temp = NULL;
char *addr_str = stream_addr_to_str(key_streamaddr);
HASH_FIND(hh2, table->streamaddr_root, key_streamaddr, sizeof(*key_streamaddr), temp);
if (!temp)
{
LOG_DEBUG("stream table search: key %s not exists", addr_str);
free(addr_str);
addr_str = NULL;
return NULL;
}
LOG_DEBUG("stream table search: key %s success", addr_str);
free(addr_str);
addr_str = NULL;
return temp;
}

23
common/test/CMakeLists.txt Normal file
View File

@@ -0,0 +1,23 @@
###############################################################################
# gtest_stream_addr
###############################################################################
add_executable(gtest_stream_addr gtest_stream_addr.cpp)
target_include_directories(gtest_stream_addr PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_stream_addr common gtest)
###############################################################################
# gtest_stream_table
###############################################################################
add_executable(gtest_stream_table gtest_stream_table.cpp)
target_include_directories(gtest_stream_table PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_stream_table common gtest)
###############################################################################
# gtest_discover_tests
###############################################################################
include(GoogleTest)
gtest_discover_tests(gtest_stream_addr)
gtest_discover_tests(gtest_stream_table)

40
common/test/gtest_stream_addr.cpp Normal file
View File

@@ -0,0 +1,40 @@
#include <gtest/gtest.h>
#include <arpa/inet.h>
#include "stream_addr.h"
TEST(STREAM_ADDR, IPV4)
{
struct stream_addr addr;
addr.addr_type = STREAM_ADDR_TYPE_V4;
addr.addr_v4.src_port = htons(12345);
addr.addr_v4.dst_port = htons(23456);
inet_pton(AF_INET, "1.2.3.4", &addr.addr_v4.src_addr);
inet_pton(AF_INET, "4.3.2.1", &addr.addr_v4.dst_addr);
char *ret_str = stream_addr_to_str(&addr);
EXPECT_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "1.2.3.4 12345 4.3.2.1 23456");
free(ret_str);
}
TEST(STREAM_ADDR, IPV6)
{
struct stream_addr addr;
addr.addr_type = STREAM_ADDR_TYPE_V6;
addr.addr_v6.src_port = htons(12345);
addr.addr_v6.dst_port = htons(23456);
inet_pton(AF_INET6, "1:2::3", &addr.addr_v6.src_addr);
inet_pton(AF_INET6, "a:b::c", &addr.addr_v6.dst_addr);
char *ret_str = stream_addr_to_str(&addr);
EXPECT_TRUE(ret_str != nullptr);
EXPECT_STREQ(ret_str, "1:2::3 12345 a:b::c 23456");
free(ret_str);
}
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

84
common/test/gtest_stream_table.cpp Normal file
View File

@@ -0,0 +1,84 @@
#include <gtest/gtest.h>
#include <arpa/inet.h>
#include "stream_table.h"
#define INIT_ADDR_V4(name, src_addr_str, src_port_num, dst_addr_str, dst_port_num) \
struct stream_addr name; \
memset(&name, 0, sizeof(name)); \
(name).addr_type = STREAM_ADDR_TYPE_V4; \
(name).addr_v4.src_port = htons((src_port_num)); \
(name).addr_v4.dst_port = htons((dst_port_num)); \
inet_pton(AF_INET, (src_addr_str), &(name).addr_v4.src_addr); \
inet_pton(AF_INET, (dst_addr_str), &(name).addr_v4.dst_addr);
#define INIT_ADDR_V6(name, src_addr_str, src_port_num, dst_addr_str, dst_port_num) \
struct stream_addr name; \
memset(&name, 0, sizeof(name)); \
(name).addr_type = STREAM_ADDR_TYPE_V6; \
(name).addr_v6.src_port = htons((src_port_num)); \
(name).addr_v6.dst_port = htons((dst_port_num)); \
inet_pton(AF_INET6, (src_addr_str), &(name).addr_v6.src_addr); \
inet_pton(AF_INET6, (dst_addr_str), &(name).addr_v6.dst_addr);
TEST(STREAM_TABLE, TEST)
{
INIT_ADDR_V4(addr1, "1.2.3.4", 1234, "4.3.2.1", 4321);
INIT_ADDR_V6(addr2, "2:3:4::5", 2345, "5:4:3::2", 5342);
struct stream_addr addr3;
char *val_hello = strdup("HELLO");
char *val_world = strdup("WORLD");
struct stream_node *node = NULL;
// TEST Create
struct stream_table *table = stream_table_create();
EXPECT_TRUE(table != nullptr);
// TEST Insert
EXPECT_TRUE(stream_table_insert(table, 1, &addr1, val_hello, free) == 0);
EXPECT_TRUE(stream_table_insert(table, 1, &addr1, val_hello, free) == -1);
EXPECT_TRUE(stream_table_insert(table, 2, &addr2, val_world, free) == 0);
EXPECT_TRUE(stream_table_insert(table, 2, &addr2, val_world, free) == -1);
// TEST Search
node = stream_table_search_by_streamid(table, 1);
EXPECT_TRUE(node != nullptr);
EXPECT_STREQ((const char *)node->val_data, "HELLO");
node = stream_table_search_by_streamid(table, 2);
EXPECT_TRUE(node != nullptr);
EXPECT_STREQ((const char *)node->val_data, "WORLD");
node = stream_table_search_by_streamid(table, 3);
EXPECT_TRUE(node == nullptr);
node = stream_table_search_by_streamaddr(table, &addr1);
EXPECT_TRUE(node != nullptr);
EXPECT_STREQ((const char *)node->val_data, "HELLO");
node = stream_table_search_by_streamaddr(table, &addr2);
EXPECT_TRUE(node != nullptr);
EXPECT_STREQ((const char *)node->val_data, "WORLD");
node = stream_table_search_by_streamaddr(table, &addr3);
EXPECT_TRUE(node == nullptr);
// TEST Delete
stream_table_delete_by_streamid(table, 1);
node = stream_table_search_by_streamid(table, 1);
EXPECT_TRUE(node == nullptr);
node = stream_table_search_by_streamaddr(table, &addr1);
EXPECT_TRUE(node == nullptr);
stream_table_delete_by_streamaddr(table, &addr2);
node = stream_table_search_by_streamid(table, 2);
EXPECT_TRUE(node == nullptr);
node = stream_table_search_by_streamaddr(table, &addr1);
EXPECT_TRUE(node == nullptr);
// TEST Destory
stream_table_destory(table);
}
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

21
vendor/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,21 @@
include(ExternalProject)
# GoogleTest
ExternalProject_Add(googletest PREFIX googletest
URL ${CMAKE_CURRENT_SOURCE_DIR}/googletest-release-1.8.0.tar.gz
URL_MD5 16877098823401d1bf2ed7891d7dce36
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE})
ExternalProject_Get_Property(googletest INSTALL_DIR)
file(MAKE_DIRECTORY ${INSTALL_DIR}/include)
add_library(gtest STATIC IMPORTED GLOBAL)
add_dependencies(gtest googletest)
set_property(TARGET gtest PROPERTY IMPORTED_LOCATION ${INSTALL_DIR}/lib/libgtest.a)
set_property(TARGET gtest PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${INSTALL_DIR}/include)
set_property(TARGET gtest PROPERTY INTERFACE_LINK_LIBRARIES pthread)
add_library(gmock STATIC IMPORTED GLOBAL)
add_dependencies(gmock googletest)
set_property(TARGET gmock PROPERTY IMPORTED_LOCATION ${INSTALL_DIR}/lib/libgmock.a)
set_property(TARGET gmock PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${INSTALL_DIR}/include)

BIN
vendor/googletest-release-1.8.0.tar.gz vendored Normal file
View File

Binary file not shown.