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

Optimize integration testing

Browse Source 
- Add injection package plug-in
- Add libstellar_dynamic.so to facilitate unit testing of upper-level plug-ins
This commit is contained in:
luwenpeng
2024-05-28 10:26:29 +08:00
parent 54385ed08b
commit f82b85c979
86 changed files with 831 additions and 831 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/id_generator/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
add_library(id_generator id_generator.cpp)
target_include_directories(id_generator PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(id_generator PUBLIC ${CMAKE_SOURCE_DIR}/src/stellar)
target_link_libraries(id_generator log core)
target_link_libraries(id_generator log stellar_core)

2
src/plugin/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
add_library(plugin_manager plugin_manager.cpp)
target_include_directories(plugin_manager PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(plugin_manager PUBLIC ${CMAKE_SOURCE_DIR}/deps/)
target_link_libraries(plugin_manager bitmap toml session_manager core ${CMAKE_DL_LIBS})
target_link_libraries(plugin_manager bitmap toml session_manager stellar_core ${CMAKE_DL_LIBS})

38
src/plugin/plugin_manager.cpp
View File

@@ -2,10 +2,6 @@
#include "plugin_manager.h"
#include "session_priv.h"
#include "stellar_priv.h"
#include "plugin_manager.h"
#include "stellar/utils.h"
#include "stellar/session.h"
#include "stellar/session_exdata.h"
@@ -156,18 +152,6 @@ inline static struct session *plugin_manager_scratch_session_get()
return per_thread_scratch_sess;
}
inline struct plugin_manager_schema * stellar_plugin_manager_schema_get(struct stellar *st)
{
return st->st_rt->plug_mgr;
}
inline int stellar_plugin_manager_schema_set(struct stellar *st, struct plugin_manager_schema *pm)
{
if(st->st_rt->plug_mgr)return -1;
st->st_rt->plug_mgr=pm;
return 0;
}
UT_icd plugin_specs_icd = {sizeof(struct plugin_specific), NULL, NULL, NULL};
static struct plugin_specific *plugin_specs_load(const char *toml_conf_path, int *spec_num)
@@ -251,9 +235,7 @@ struct plugin_manager_schema *plugin_manager_init(struct stellar *st, const char
}
pm->st = st;
stellar_plugin_manager_schema_set(st, pm);
stellar_set_plugin_manger(st, pm);
pm->tcp_topic_id=stellar_session_mq_create_topic(st, TOPIC_TCP, NULL, NULL);
pm->tcp_stream_topic_id=stellar_session_mq_create_topic(st, TOPIC_TCP_STREAM, tcp_stream_msg_free_fn, NULL);
pm->udp_topic_id=stellar_session_mq_create_topic(st, TOPIC_UDP, NULL, NULL);
@@ -334,7 +316,7 @@ UT_icd session_exdata_meta_icd = {sizeof(struct session_exdata_schema), NULL, se
int stellar_session_exdata_new_index(struct stellar *st, const char *name, session_exdata_free *free_func,void *free_arg)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->session_exdata_schema_array == NULL)
{
utarray_new(plug_mgr->session_exdata_schema_array, &session_exdata_meta_icd);
@@ -423,7 +405,7 @@ void session_mq_free(struct session_message *head)
int stellar_session_mq_get_topic_id(struct stellar *st, const char *topic_name)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);;
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);;
if(topic_name == NULL || plug_mgr == NULL || plug_mgr->session_mq_schema_array == NULL)return -1;
unsigned int len = utarray_len(plug_mgr->session_mq_schema_array);
struct session_mq_topic_schema *t_schema;
@@ -440,7 +422,7 @@ int stellar_session_mq_get_topic_id(struct stellar *st, const char *topic_name)
int stellar_session_mq_update_topic(struct stellar *st, int topic_id, msg_free_cb_func *msg_free_cb, void *msg_free_arg)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->session_mq_schema_array == NULL)return -1;
unsigned int len = utarray_len(plug_mgr->session_mq_schema_array);
if(len < (unsigned int)topic_id)return -1;
@@ -453,7 +435,7 @@ int stellar_session_mq_update_topic(struct stellar *st, int topic_id, msg_free_c
int stellar_session_mq_create_topic(struct stellar *st, const char *topic_name, msg_free_cb_func *msg_free_cb, void *msg_free_arg)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->session_mq_schema_array == NULL)
{
utarray_new(plug_mgr->session_mq_schema_array, &session_mq_topic_schema_icd);
@@ -478,7 +460,7 @@ int stellar_session_mq_create_topic(struct stellar *st, const char *topic_name,
int stellar_session_mq_destroy_topic(struct stellar *st, int topic_id)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->session_mq_schema_array==NULL)return 0;
unsigned int len = utarray_len(plug_mgr->session_mq_schema_array);
if (len <= (unsigned int)topic_id)
@@ -559,7 +541,7 @@ UT_icd session_mq_subscriber_info_icd = {sizeof(struct session_mq_subscriber_inf
int stellar_session_mq_subscribe(struct stellar *st, int topic_id, on_msg_cb_func *plugin_on_msg_cb, int plugin_id)
{
if(plugin_id >= PACKET_PULGIN_ID_BASE)return -1;// ignore packet plugin
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->session_mq_schema_array==NULL)return -1;
unsigned int len = utarray_len(plug_mgr->session_mq_schema_array);
if (len <= (unsigned int)topic_id)return -1;
@@ -743,7 +725,7 @@ UT_icd registered_packet_plugin_array_icd = {sizeof(struct registered_packet_plu
int stellar_packet_plugin_register(struct stellar *st, unsigned char ip_protocol, plugin_on_packet_func on_packet, void *plugin_env)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->registered_packet_plugin_array == NULL)
{
utarray_new(plug_mgr->registered_packet_plugin_array, &registered_packet_plugin_array_icd);
@@ -783,7 +765,7 @@ UT_icd registered_polling_plugin_array_icd = {sizeof(struct registered_polling_p
int stellar_polling_plugin_register(struct stellar *st, plugin_on_polling_func on_polling, void *plugin_env)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->registered_polling_plugin_array == NULL)
{
utarray_new(plug_mgr->registered_polling_plugin_array, &registered_polling_plugin_array_icd);
@@ -828,7 +810,7 @@ int stellar_session_plugin_register(struct stellar *st,
session_ctx_free_func session_ctx_free,
void *plugin_env)
{
struct plugin_manager_schema *plug_mgr = stellar_plugin_manager_schema_get(st);
struct plugin_manager_schema *plug_mgr = stellar_get_plugin_manager(st);
if(plug_mgr->registered_session_plugin_array == NULL)
{
utarray_new(plug_mgr->registered_session_plugin_array, &registered_session_plugin_schema_icd);

18
src/stellar/CMakeLists.txt
View File

@@ -1,7 +1,17 @@
add_library(core config.cpp stat.cpp stellar.cpp inject.cpp)
target_link_libraries(core times plugin_manager session_manager ip_reassembly packet_io pthread fieldstat4 toml)
set(SOURCE config.cpp stat.cpp stellar.cpp inject.cpp)
set(LIBRARY times plugin_manager session_manager ip_reassembly packet_io pthread fieldstat4 toml)
add_library(stellar_core STATIC ${SOURCE})
target_link_libraries(stellar_core ${LIBRARY})
add_library(stellar_devel SHARED ${SOURCE})
target_link_libraries(stellar_devel ${LIBRARY})
set_target_properties(stellar_devel PROPERTIES LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/version.map")
add_executable(stellar main.cpp)
target_link_libraries(stellar core)
target_link_libraries(stellar stellar_core)
target_link_libraries(stellar "-rdynamic")
install(TARGETS stellar RUNTIME DESTINATION bin COMPONENT Program)
set_target_properties(stellar PROPERTIES LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/version.map")
install(TARGETS stellar RUNTIME DESTINATION bin COMPONENT Program)
install(TARGETS stellar_devel LIBRARY DESTINATION lib COMPONENT LIBRARIES)

32
src/stellar/inject.cpp
View File

@@ -386,7 +386,7 @@ int build_udp_packet(const struct packet *first, const char *udp_pld, int pld_le
return len - trim;
}
int inject_tcp_packet(const struct session *sess, enum flow_direction inject_dir, uint8_t tcp_flags, const char *payload, uint16_t len)
int inject_tcp_packet(struct stellar *st, const struct session *sess, enum flow_direction inject_dir, uint8_t tcp_flags, const char *payload, uint16_t len)
{
#define TCP_FLAGS_LOG_FORMAT "URG:%d, ACK:%d, PSH:%d, RST:%d, SYN:%d, FIN:%d"
#define TCP_FLAGS_LOG_VALUE(flags) \
@@ -396,6 +396,8 @@ int inject_tcp_packet(const struct session *sess, enum flow_direction inject_dir
uint16_t thr_idx = stellar_get_current_thread_index();
uint64_t time_ms = stellar_get_monotonic_time_msec();
struct packet_io *packet_io = stellar_get_packet_io(st);
struct session_manager *sess_mgr = stellar_get_session_manager(st);
if (session_get_type(sess) != SESSION_TYPE_TCP)
{
@@ -442,8 +444,8 @@ int inject_tcp_packet(const struct session *sess, enum flow_direction inject_dir
packet_parse(&inj_pkt, buff, pkt_len);
packet_set_origin(&inj_pkt, PACKET_ORIGIN_USERSTACK);
packet_set_origin_ctx(&inj_pkt, &meta);
session_manager_record_duplicated_packet(runtime->threads[thr_idx].sess_mgr, &inj_pkt, time_ms);
if (packet_io_inject(runtime->packet_io, thr_idx, &inj_pkt, 1) == 1)
session_manager_record_duplicated_packet(sess_mgr, &inj_pkt, time_ms);
if (packet_io_inject(packet_io, thr_idx, &inj_pkt, 1) == 1)
{
session_inc_stat((struct session *)sess, inject_dir, STAT_INJECTED_PACKETS_SUCCESS, 1);
session_inc_stat((struct session *)sess, inject_dir, STAT_INJECTED_BYTES_SUCCESS, pkt_len);
@@ -462,10 +464,12 @@ int inject_tcp_packet(const struct session *sess, enum flow_direction inject_dir
}
}
int inject_udp_packet(const struct session *sess, enum flow_direction inject_dir, const char *payload, uint16_t len)
int inject_udp_packet(struct stellar *st, const struct session *sess, enum flow_direction inject_dir, const char *payload, uint16_t len)
{
uint16_t thr_idx = stellar_get_current_thread_index();
uint64_t time_ms = stellar_get_monotonic_time_msec();
struct packet_io *packet_io = stellar_get_packet_io(st);
struct session_manager *sess_mgr = stellar_get_session_manager(st);
if (session_get_type(sess) != SESSION_TYPE_UDP)
{
@@ -505,8 +509,8 @@ int inject_udp_packet(const struct session *sess, enum flow_direction inject_dir
packet_parse(&inj_pkt, buff, pkt_len);
packet_set_origin(&inj_pkt, PACKET_ORIGIN_USERSTACK);
packet_set_origin_ctx(&inj_pkt, &meta);
session_manager_record_duplicated_packet(runtime->threads[thr_idx].sess_mgr, &inj_pkt, time_ms);
if (packet_io_inject(runtime->packet_io, thr_idx, &inj_pkt, 1) == 1)
session_manager_record_duplicated_packet(sess_mgr, &inj_pkt, time_ms);
if (packet_io_inject(packet_io, thr_idx, &inj_pkt, 1) == 1)
{
session_inc_stat((struct session *)sess, inject_dir, STAT_INJECTED_PACKETS_SUCCESS, 1);
session_inc_stat((struct session *)sess, inject_dir, STAT_INJECTED_BYTES_SUCCESS, pkt_len);
@@ -529,30 +533,30 @@ int inject_udp_packet(const struct session *sess, enum flow_direction inject_dir
* Public API
******************************************************************************/
int stellar_inject_tcp_rst(const struct session *sess, enum flow_direction inject_dir)
int stellar_inject_tcp_rst(struct stellar *st, const struct session *sess, enum flow_direction inject_dir)
{
return inject_tcp_packet(sess, inject_dir, TH_RST | TH_ACK, NULL, 0);
return inject_tcp_packet(st, sess, inject_dir, TH_RST | TH_ACK, NULL, 0);
}
int stellar_inject_tcp_fin(const struct session *sess, enum flow_direction inject_dir)
int stellar_inject_tcp_fin(struct stellar *st, const struct session *sess, enum flow_direction inject_dir)
{
return inject_tcp_packet(sess, inject_dir, TH_FIN | TH_ACK, NULL, 0);
return inject_tcp_packet(st, sess, inject_dir, TH_FIN | TH_ACK, NULL, 0);
}
int stellar_inject_payload(const struct session *sess, enum flow_direction inject_dir, const char *payload, uint16_t len)
int stellar_inject_payload(struct stellar *st, const struct session *sess, enum flow_direction inject_dir, const char *payload, uint16_t len)
{
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
return inject_tcp_packet(sess, inject_dir, TH_ACK, payload, len);
return inject_tcp_packet(st, sess, inject_dir, TH_ACK, payload, len);
case SESSION_TYPE_UDP:
return inject_udp_packet(sess, inject_dir, payload, len);
return inject_udp_packet(st, sess, inject_dir, payload, len);
default:
return 0;
}
}
int stellar_inject_ctrl_msg(const struct session *sess, const struct sid_list *sids, const char *msg, uint16_t len)
int stellar_inject_ctrl_msg(struct stellar *st, const struct session *sess, const struct sid_list *sids, const char *msg, uint16_t len)
{
// TODO
return 0;

165
src/stellar/main.cpp
View File

@@ -1,169 +1,6 @@
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include "logo.h"
#include "times.h"
#include "config.h"
#include "id_generator.h"
#include "stellar_priv.h"
static const char *log_config_file = "./conf/log.toml";
static const char *stellar_config_file = "./conf/stellar.toml";
static void signal_handler(int signo)
{
if (signo == SIGINT)
{
STELLAR_LOG_STATE("SIGINT received, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
if (signo == SIGQUIT)
{
STELLAR_LOG_STATE("SIGQUIT received, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
if (signo == SIGTERM)
{
STELLAR_LOG_STATE("SIGTERM received, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
if (signo == SIGHUP)
{
STELLAR_LOG_STATE("SIGHUP received, reload log level !!!");
log_reload_level(log_config_file);
}
}
static int all_session_have_freed(void)
{
for (int i = 0; i < config->io_opts.nr_threads; i++)
{
struct session_manager *sess_mgr = runtime->threads[i].sess_mgr;
struct session_manager_stat *sess_stat = session_manager_stat(sess_mgr);
if (ATOMIC_READ(&sess_stat->curr_nr_tcp_sess_used) != 0)
{
return 0;
}
if (ATOMIC_READ(&sess_stat->curr_nr_udp_sess_used) != 0)
{
return 0;
}
}
return 1;
}
static int all_stat_have_output(void)
{
static int count = 0;
if (runtime->stat_last_output_ts == stellar_get_monotonic_time_msec())
{
count++;
}
return count == 2;
}
int main(int argc, char **argv)
{
struct stellar st = {runtime};
stellar_update_time_cache();
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGHUP, signal_handler);
if (log_init(log_config_file) != 0)
{
STELLAR_LOG_ERROR("unable to init log");
goto error_out;
}
STELLAR_LOG_STATE("start stellar (version: %s)\n %s", __stellar_version, logo_str);
if (stellar_load_config(stellar_config_file, config) != 0)
{
STELLAR_LOG_ERROR("unable to load config file");
goto error_out;
}
stellar_print_config(config);
STELLAR_LOG_DEBUG("sizeof(struct session) = %lu bytes", sizeof(struct session));
if (id_generator_init(config->dev_opts.base, config->dev_opts.offset) != 0)
{
STELLAR_LOG_ERROR("unable to init id generator");
goto error_out;
}
runtime->stat = stellar_stat_new(config->io_opts.nr_threads);
if (runtime->stat == NULL)
{
STELLAR_LOG_ERROR("unable to create stellar stat");
goto error_out;
}
runtime->plug_mgr = plugin_manager_init(&st, "./stellar_plugin/spec.toml");
if (runtime->plug_mgr == NULL)
{
STELLAR_LOG_ERROR("unable to create plugin manager");
goto error_out;
}
runtime->packet_io = packet_io_new(&config->io_opts);
if (runtime->packet_io == NULL)
{
STELLAR_LOG_ERROR("unable to create packet io");
goto error_out;
}
if (stellar_thread_init(runtime, config) != 0)
{
STELLAR_LOG_ERROR("unable to init thread context");
goto error_out;
}
if (stellar_thread_run(runtime, config) != 0)
{
STELLAR_LOG_ERROR("unable to create worker thread");
goto error_out;
}
runtime->stat_last_output_ts = stellar_get_monotonic_time_msec();
while (!ATOMIC_READ(&runtime->need_exit))
{
stellar_update_time_cache();
if (stellar_get_monotonic_time_msec() - runtime->stat_last_output_ts > 2000)
{
runtime->stat_last_output_ts = stellar_get_monotonic_time_msec();
stellar_stat_output(runtime->stat);
}
usleep(1000); // 1ms
// Only available in dump file mode, automatically exits when all sessions have been released
if (packet_io_wait_exit(runtime->packet_io) && all_session_have_freed() && all_stat_have_output())
{
STELLAR_LOG_STATE("all sessions have been released and all stat have been output, notify threads to exit !!!");
ATOMIC_SET(&runtime->need_exit, 1);
}
}
error_out:
stellar_thread_join(runtime, config);
stellar_thread_clean(runtime, config);
packet_io_free(runtime->packet_io);
plugin_manager_exit(runtime->plug_mgr);
stellar_stat_free(runtime->stat);
STELLAR_LOG_STATE("stellar exit !!!\n");
log_free();
return 0;
return stellar_main(argc, argv);
}

255
src/stellar/stellar.cpp
View File

@@ -2,17 +2,53 @@
#include <assert.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <sys/prctl.h>
#include "stat.h"
#include "logo.h"
#include "times.h"
#include "config.h"
#include "id_generator.h"
#include "stellar_priv.h"
#include "plugin_manager.h"
struct stellar_runtime __runtime = {0};
struct stellar_runtime *runtime = &__runtime;
struct stellar_thread
{
pthread_t tid;
uint16_t idx;
uint64_t is_runing;
uint64_t timing_wheel_last_update_ts;
struct ip_reassembly *ip_mgr;
struct session_manager *sess_mgr;
struct stellar_runtime *runtime;
};
struct stellar_config __config = {0};
struct stellar_config *config = &__config;
struct stellar_runtime
{
uint64_t need_exit;
uint64_t stat_last_output_ts;
struct stellar_stat *stat;
struct packet_io *packet_io;
struct plugin_manager_schema *plug_mgr;
struct stellar_thread threads[MAX_THREAD_NUM];
};
struct stellar
{
struct stellar_runtime runtime;
struct stellar_config config;
};
static uint64_t need_exit = 0;
static thread_local uint16_t __thread_id = 0;
static const char *log_config_file = "./conf/log.toml";
static const char *main_config_file = "./conf/stellar.toml";
static const char *plugin_config_file = "./stellar_plugin/spec.toml";
/******************************************************************************
* Stellar Thread Main Loop
******************************************************************************/
static void update_session_stat(struct session *sess, struct packet *pkt)
{
@@ -83,6 +119,7 @@ static inline void free_expired_sessions(struct session_manager *sess_mgr, uint6
static inline void merge_thread_stat(struct stellar_thread *thread, uint64_t now)
{
struct stellar_runtime *runtime = thread->runtime;
struct thread_stat thr_stat = {
packet_io_stat(runtime->packet_io, thread->idx),
ip_reassembly_stat(thread->ip_mgr),
@@ -101,13 +138,15 @@ static void *work_thread(void *arg)
struct packet *defraged_pkt = NULL;
struct packet packets[RX_BURST_MAX];
struct session *sess = NULL;
struct packet_io *packet_io = runtime->packet_io;
struct plugin_manager_schema *plug_mgr = runtime->plug_mgr;
struct stellar_thread *thread = (struct stellar_thread *)arg;
struct ip_reassembly *ip_reass = thread->ip_mgr;
struct session_manager *sess_mgr = thread->sess_mgr;
struct stellar_runtime *runtime = thread->runtime;
struct packet_io *packet_io = runtime->packet_io;
struct plugin_manager_schema *plug_mgr = runtime->plug_mgr;
uint16_t thr_idx = thread->idx;
stellar_set_current_thread_index(thr_idx);
__thread_id = thr_idx;
snprintf(thd_name, sizeof(thd_name), "stellar:%d", thr_idx);
prctl(PR_SET_NAME, (unsigned long long)thd_name, NULL, NULL, NULL);
@@ -121,7 +160,7 @@ static void *work_thread(void *arg)
ATOMIC_SET(&thread->is_runing, 1);
STELLAR_LOG_STATE("worker thread %d runing", thr_idx);
while (ATOMIC_READ(&runtime->need_exit) == 0)
while (ATOMIC_READ(&need_exit) == 0)
{
now = stellar_get_monotonic_time_msec();
memset(packets, 0, sizeof(packets));
@@ -236,19 +275,70 @@ static void *work_thread(void *arg)
return NULL;
}
static thread_local uint16_t __thread_id = 0;
/******************************************************************************
* Stellar Main Function
******************************************************************************/
uint16_t stellar_get_current_thread_index()
static void signal_handler(int signo)
{
return __thread_id;
if (signo == SIGINT)
{
STELLAR_LOG_STATE("SIGINT received, notify threads to exit !!!");
ATOMIC_SET(&need_exit, 1);
}
if (signo == SIGQUIT)
{
STELLAR_LOG_STATE("SIGQUIT received, notify threads to exit !!!");
ATOMIC_SET(&need_exit, 1);
}
if (signo == SIGTERM)
{
STELLAR_LOG_STATE("SIGTERM received, notify threads to exit !!!");
ATOMIC_SET(&need_exit, 1);
}
if (signo == SIGHUP)
{
STELLAR_LOG_STATE("SIGHUP received, reload log level !!!");
log_reload_level(log_config_file);
}
}
void stellar_set_current_thread_index(uint16_t idx)
static int all_session_have_freed(struct stellar_runtime *runtime, struct stellar_config *config)
{
__thread_id = idx;
for (int i = 0; i < config->io_opts.nr_threads; i++)
{
struct session_manager *sess_mgr = runtime->threads[i].sess_mgr;
struct session_manager_stat *sess_stat = session_manager_stat(sess_mgr);
if (ATOMIC_READ(&sess_stat->curr_nr_tcp_sess_used) != 0)
{
return 0;
}
if (ATOMIC_READ(&sess_stat->curr_nr_udp_sess_used) != 0)
{
return 0;
}
}
return 1;
}
int stellar_thread_init(struct stellar_runtime *runtime, struct stellar_config *config)
static int all_stat_have_output(struct stellar_runtime *runtime, struct stellar_config *config)
{
static int count = 0;
if (runtime->stat_last_output_ts == stellar_get_monotonic_time_msec())
{
count++;
}
return count == 2;
}
static int stellar_thread_init(struct stellar_runtime *runtime, struct stellar_config *config)
{
uint64_t now = stellar_get_monotonic_time_msec();
for (uint16_t i = 0; i < config->io_opts.nr_threads; i++)
@@ -269,12 +359,13 @@ int stellar_thread_init(struct stellar_runtime *runtime, struct stellar_config *
STELLAR_LOG_ERROR("unable to create ip reassemble manager");
return -1;
}
thread->runtime = runtime;
}
return 0;
}
void stellar_thread_clean(struct stellar_runtime *runtime, struct stellar_config *config)
static void stellar_thread_clean(struct stellar_runtime *runtime, struct stellar_config *config)
{
for (uint16_t i = 0; i < config->io_opts.nr_threads; i++)
{
@@ -288,7 +379,7 @@ void stellar_thread_clean(struct stellar_runtime *runtime, struct stellar_config
}
}
int stellar_thread_run(struct stellar_runtime *runtime, struct stellar_config *config)
static int stellar_thread_run(struct stellar_runtime *runtime, struct stellar_config *config)
{
for (uint16_t i = 0; i < config->io_opts.nr_threads; i++)
{
@@ -303,7 +394,7 @@ int stellar_thread_run(struct stellar_runtime *runtime, struct stellar_config *c
return 0;
}
void stellar_thread_join(struct stellar_runtime *runtime, struct stellar_config *config)
static void stellar_thread_join(struct stellar_runtime *runtime, struct stellar_config *config)
{
for (uint16_t i = 0; i < config->io_opts.nr_threads; i++)
{
@@ -315,3 +406,133 @@ void stellar_thread_join(struct stellar_runtime *runtime, struct stellar_config
}
}
}
int stellar_main(int argc, char **argv)
{
static struct stellar st = {0};
static struct stellar_runtime *runtime = &st.runtime;
static struct stellar_config *config = &st.config;
stellar_update_time_cache();
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGHUP, signal_handler);
if (log_init(log_config_file) != 0)
{
STELLAR_LOG_ERROR("unable to init log");
goto error_out;
}
STELLAR_LOG_STATE("start stellar (version: %s)\n %s", __stellar_version, logo_str);
STELLAR_LOG_STATE("log config file : %s", log_config_file);
STELLAR_LOG_STATE("main config file : %s", main_config_file);
STELLAR_LOG_STATE("plugin config file : %s", plugin_config_file);
if (stellar_load_config(main_config_file, config) != 0)
{
STELLAR_LOG_ERROR("unable to load config file");
goto error_out;
}
stellar_print_config(config);
STELLAR_LOG_DEBUG("sizeof(struct session) = %lu bytes", sizeof(struct session));
if (id_generator_init(config->dev_opts.base, config->dev_opts.offset) != 0)
{
STELLAR_LOG_ERROR("unable to init id generator");
goto error_out;
}
runtime->stat = stellar_stat_new(config->io_opts.nr_threads);
if (runtime->stat == NULL)
{
STELLAR_LOG_ERROR("unable to create stellar stat");
goto error_out;
}
runtime->plug_mgr = plugin_manager_init(&st, plugin_config_file);
if (runtime->plug_mgr == NULL)
{
STELLAR_LOG_ERROR("unable to create plugin manager");
goto error_out;
}
runtime->packet_io = packet_io_new(&config->io_opts);
if (runtime->packet_io == NULL)
{
STELLAR_LOG_ERROR("unable to create packet io");
goto error_out;
}
if (stellar_thread_init(runtime, config) != 0)
{
STELLAR_LOG_ERROR("unable to init thread context");
goto error_out;
}
if (stellar_thread_run(runtime, config) != 0)
{
STELLAR_LOG_ERROR("unable to create worker thread");
goto error_out;
}
runtime->stat_last_output_ts = stellar_get_monotonic_time_msec();
while (!ATOMIC_READ(&need_exit))
{
stellar_update_time_cache();
if (stellar_get_monotonic_time_msec() - runtime->stat_last_output_ts > 2000)
{
runtime->stat_last_output_ts = stellar_get_monotonic_time_msec();
stellar_stat_output(runtime->stat);
}
usleep(1000); // 1ms
// Only available in dump file mode, automatically exits when all sessions have been released
if (packet_io_wait_exit(runtime->packet_io) && all_session_have_freed(runtime, config) && all_stat_have_output(runtime, config))
{
STELLAR_LOG_STATE("all sessions have been released and all stat have been output, notify threads to exit !!!");
ATOMIC_SET(&need_exit, 1);
}
}
error_out:
stellar_thread_join(runtime, config);
stellar_thread_clean(runtime, config);
packet_io_free(runtime->packet_io);
plugin_manager_exit(runtime->plug_mgr);
stellar_stat_free(runtime->stat);
STELLAR_LOG_STATE("stellar exit !!!\n");
log_free();
return 0;
}
/******************************************************************************
* Stellar Utility Function
******************************************************************************/
struct packet_io *stellar_get_packet_io(const struct stellar *st)
{
return st->runtime.packet_io;
}
struct plugin_manager_schema *stellar_get_plugin_manager(const struct stellar *st)
{
return st->runtime.plug_mgr;
}
void stellar_set_plugin_manger(struct stellar *st, struct plugin_manager_schema *plug_mgr)
{
st->runtime.plug_mgr = plug_mgr;
}
struct session_manager *stellar_get_session_manager(const struct stellar *st)
{
uint16_t idx = stellar_get_current_thread_index();
return st->runtime.threads[idx].sess_mgr;
}
uint16_t stellar_get_current_thread_index()
{
return __thread_id;
}

41
src/stellar/stellar_priv.h
View File

@@ -6,49 +6,16 @@ extern "C"
{
#endif
#include "stat.h"
#include "plugin_manager.h"
#include "stellar/stellar.h"
#define STELLAR_LOG_STATE(format, ...) LOG_STATE("stellar", format, ##__VA_ARGS__)
#define STELLAR_LOG_ERROR(format, ...) LOG_ERROR("stellar", format, ##__VA_ARGS__)
#define STELLAR_LOG_DEBUG(format, ...) LOG_DEBUG("stellar", format, ##__VA_ARGS__)
struct stellar_thread
{
pthread_t tid;
uint16_t idx;
uint64_t is_runing;
uint64_t timing_wheel_last_update_ts;
struct ip_reassembly *ip_mgr;
struct session_manager *sess_mgr;
};
struct stellar_runtime
{
uint64_t need_exit;
uint64_t stat_last_output_ts;
struct stellar_stat *stat;
struct packet_io *packet_io;
struct plugin_manager_schema *plug_mgr;
struct stellar_thread threads[MAX_THREAD_NUM];
};
//FIXME rename stellar_runtime to stellar
struct stellar
{
struct stellar_runtime *st_rt;
};
extern struct stellar_runtime *runtime;
extern struct stellar_config *config;
void stellar_set_current_thread_index(uint16_t idx);
int stellar_thread_init(struct stellar_runtime *runtime, struct stellar_config *config);
void stellar_thread_clean(struct stellar_runtime *runtime, struct stellar_config *config);
int stellar_thread_run(struct stellar_runtime *runtime, struct stellar_config *config);
void stellar_thread_join(struct stellar_runtime *runtime, struct stellar_config *config);
struct packet_io *stellar_get_packet_io(const struct stellar *st);
struct session_manager *stellar_get_session_manager(const struct stellar *st);
struct plugin_manager_schema *stellar_get_plugin_manager(const struct stellar *st);
void stellar_set_plugin_manger(struct stellar *st, struct plugin_manager_schema *plug_mgr);
#ifdef __cplusplus
}

84
src/stellar/version.map Normal file
View File

@@ -0,0 +1,84 @@
LIBSTELLAR_DEVEL {
global:
packet_get_innermost_tuple2;
packet_get_outermost_tuple2;
packet_get_innermost_tuple4;
packet_get_outermost_tuple4;
packet_get_innermost_tuple6;
packet_get_outermost_tuple6;
packet_get_innermost_layer;
packet_get_outermost_layer;
packet_get_direction;
packet_get_session_id;
packet_prepend_sid_list;
packet_get_layers_number;
packet_get_layer;
packet_get_data;
packet_get_len;
packet_get_payload;
packet_get_payload_len;
packet_set_action;
packet_get_action;
session_exdata_free;
stellar_session_exdata_new_index;
session_exdata_set;
session_exdata_get;
stellar_session_mq_create_topic;
stellar_session_mq_get_topic_id;
stellar_session_mq_update_topic;
stellar_session_mq_destroy_topic;
stellar_session_mq_subscribe;
session_mq_publish_message;
session_mq_ignore_message;
session_mq_unignore_message;
session_is_symmetric;
session_has_duplicate_traffic;
session_get_type;
session_get_current_state;
session_get0_current_packet;
session_get0_current_payload;
session_get_closing_reason;
session_get_direction;
session_get_current_flow_direction;
session_get_first_packet;
session_get_tuple6;
session_get_tuple6_direction;
session_get_id;
session_get_timestamp;
session_get_stat;
session_get0_readable_addr;
session_set_discard;
stellar_session_plugin_register;
stellar_session_plugin_dettach_current_session;
stellar_packet_plugin_register;
stellar_polling_plugin_register;
stellar_get_current_thread_index;
stellar_inject_tcp_rst;
stellar_inject_tcp_fin;
stellar_inject_payload;
stellar_inject_ctrl_msg;
stellar_main;
tuple2_hash;
tuple4_hash;
tuple5_hash;
tuple6_hash;
tuple2_cmp;
tuple4_cmp;
tuple5_cmp;
tuple6_cmp;
tuple2_reverse;
tuple4_reverse;
tuple5_reverse;
tuple6_reverse;
tuple2_to_str;
tuple4_to_str;
tuple5_to_str;
tuple6_to_str;
local: *;
};