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

logger changes from global static variables to one instance per stellar

Browse Source
This commit is contained in:
luwenpeng
2024-08-23 18:44:17 +08:00
parent 8db2e70c38
commit 4e524a8781
23 changed files with 306 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
include/stellar/log.h Normal file
View File

@@ -0,0 +1,62 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
enum log_level
{
LOG_TRACE,
LOG_DEBUG,
LOG_INFO,
LOG_WARN,
LOG_ERROR,
LOG_FATAL,
};
#define STELLAR_LOG_TRACE(logger, module, format, ...) \
if ((logger) && log_level_check((logger), LOG_TRACE)) \
{ \
log_print((logger), LOG_TRACE, (module), (format), ##__VA_ARGS__); \
}
#define STELLAR_LOG_DEBUG(logger, module, format, ...) \
if ((logger) && log_level_check((logger), LOG_DEBUG)) \
{ \
log_print((logger), LOG_DEBUG, (module), (format), ##__VA_ARGS__); \
}
#define STELLAR_LOG_INFO(logger, module, format, ...) \
if ((logger) && log_level_check((logger), LOG_INFO)) \
{ \
log_print((logger), LOG_INFO, (module), (format), ##__VA_ARGS__); \
}
#define STELLAR_LOG_WARN(logger, module, format, ...) \
if ((logger) && log_level_check((logger), LOG_WARN)) \
{ \
log_print((logger), LOG_WARN, (module), (format), ##__VA_ARGS__); \
}
#define STELLAR_LOG_ERROR(logger, module, format, ...) \
if ((logger) && log_level_check((logger), LOG_ERROR)) \
{ \
log_print((logger), LOG_ERROR, (module), (format), ##__VA_ARGS__); \
}
#define STELLAR_LOG_FATAL(logger, module, format, ...) \
if ((logger) && log_level_check((logger), LOG_FATAL)) \
{ \
log_print((logger), LOG_FATAL, (module), (format), ##__VA_ARGS__); \
}
struct logger;
struct logger *stellar_get_logger(struct stellar *st);
int log_level_check(struct logger *logger, enum log_level level);
void log_print(struct logger *logger, enum log_level level, const char *module, const char *fmt, ...);
#ifdef __cplusplus
}
#endif

6
src/core/stellar_config.cpp
View File

@@ -2,12 +2,12 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "log.h"
#include "toml.h" #include "toml.h"
#include "log_private.h"
#include "stellar_config.h" #include "stellar_config.h"
#define CONFIG_LOG_ERROR(format, ...) LOG_ERROR("config", format, ##__VA_ARGS__) #define CONFIG_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "config", format, ##__VA_ARGS__)
#define CONFIG_LOG_DEBUG(format, ...) LOG_DEBUG("config", format, ##__VA_ARGS__) #define CONFIG_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "config", format, ##__VA_ARGS__)
// return 0: success // return 0: success
// retuun -1: failed // retuun -1: failed

84
src/core/stellar_core.cpp
View File

@@ -8,21 +8,21 @@
#include <pthread.h> #include <pthread.h>
#include <sys/prctl.h> #include <sys/prctl.h>
#include "log.h"
#include "utils.h" #include "utils.h"
#include "packet_io.h"
#include "packet_private.h"
#include "session_private.h"
#include "snowflake.h" #include "snowflake.h"
#include "packet_io.h"
#include "log_private.h"
#include "stellar_stat.h" #include "stellar_stat.h"
#include "stellar_core.h" #include "stellar_core.h"
#include "stellar_config.h" #include "stellar_config.h"
#include "packet_private.h"
#include "plugin_manager.h" #include "plugin_manager.h"
#include "session_private.h"
#include "session_manager.h" #include "session_manager.h"
#define STELLAR_LOG_FATAL(format, ...) LOG_FATAL("stellar", format, ##__VA_ARGS__) #define CORE_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "core", format, ##__VA_ARGS__)
#define STELLAR_LOG_ERROR(format, ...) LOG_ERROR("stellar", format, ##__VA_ARGS__) #define CORE_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "core", format, ##__VA_ARGS__)
#define STELLAR_LOG_DEBUG(format, ...) LOG_DEBUG("stellar", format, ##__VA_ARGS__) #define CORE_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "core", format, ##__VA_ARGS__)
#ifdef STELLAR_GIT_VERSION #ifdef STELLAR_GIT_VERSION
static __attribute__((__used__)) const char *version = STELLAR_GIT_VERSION; static __attribute__((__used__)) const char *version = STELLAR_GIT_VERSION;
@@ -69,6 +69,7 @@ struct stellar_runtime
{ {
uint64_t need_exit; uint64_t need_exit;
uint64_t stat_last_output_ts; uint64_t stat_last_output_ts;
struct logger *logger;
struct stellar_stat *stat; struct stellar_stat *stat;
struct packet_io *packet_io; struct packet_io *packet_io;
struct plugin_manager_schema *plug_mgr; struct plugin_manager_schema *plug_mgr;
@@ -197,6 +198,7 @@ static void *work_thread(void *arg)
uint16_t thr_idx = thread->idx; uint16_t thr_idx = thread->idx;
__current_thread_idx = thr_idx; __current_thread_idx = thr_idx;
__thread_local_logger = runtime->logger;
__current_thread_snowflake = thread->snowflake; __current_thread_snowflake = thread->snowflake;
memset(packets, 0, sizeof(packets)); memset(packets, 0, sizeof(packets));
@@ -211,12 +213,12 @@ static void *work_thread(void *arg)
if (packet_io_init(packet_io, thr_idx) != 0) if (packet_io_init(packet_io, thr_idx) != 0)
{ {
STELLAR_LOG_ERROR("unable to init marsio thread"); CORE_LOG_ERROR("unable to init marsio thread");
return NULL; return NULL;
} }
ATOMIC_SET(&thread->is_runing, 1); ATOMIC_SET(&thread->is_runing, 1);
STELLAR_LOG_FATAL("worker thread %d runing", thr_idx); CORE_LOG_FATAL("worker thread %d runing", thr_idx);
while (ATOMIC_READ(&runtime->need_exit) == 0) while (ATOMIC_READ(&runtime->need_exit) == 0)
{ {
@@ -358,7 +360,7 @@ static void *work_thread(void *arg)
} }
ATOMIC_SET(&thread->is_runing, 0); ATOMIC_SET(&thread->is_runing, 0);
STELLAR_LOG_FATAL("worker thread %d exit", thr_idx); CORE_LOG_FATAL("worker thread %d exit", thr_idx);
return NULL; return NULL;
} }
@@ -416,20 +418,20 @@ static int stellar_thread_init(struct stellar *st)
thread->snowflake = snowflake_new(i, config->snowflake_opts.snowflake_base, config->snowflake_opts.snowflake_offset); thread->snowflake = snowflake_new(i, config->snowflake_opts.snowflake_base, config->snowflake_opts.snowflake_offset);
if (thread->snowflake == NULL) if (thread->snowflake == NULL)
{ {
STELLAR_LOG_ERROR("unable to create snowflake id generator"); CORE_LOG_ERROR("unable to create snowflake id generator");
return -1; return -1;
} }
thread->sess_mgr = session_manager_new(&config->sess_mgr_opts, now_ms); thread->sess_mgr = session_manager_new(&config->sess_mgr_opts, now_ms);
if (thread->sess_mgr == NULL) if (thread->sess_mgr == NULL)
{ {
STELLAR_LOG_ERROR("unable to create session manager"); CORE_LOG_ERROR("unable to create session manager");
return -1; return -1;
} }
session_manager_set_session_id_generator(thread->sess_mgr, stellar_generate_session_id); session_manager_set_session_id_generator(thread->sess_mgr, stellar_generate_session_id);
thread->ip_mgr = ip_reassembly_new(&config->ip_reass_opts); thread->ip_mgr = ip_reassembly_new(&config->ip_reass_opts);
if (thread->ip_mgr == NULL) if (thread->ip_mgr == NULL)
{ {
STELLAR_LOG_ERROR("unable to create ip reassemble manager"); CORE_LOG_ERROR("unable to create ip reassemble manager");
return -1; return -1;
} }
thread->st = st; thread->st = st;
@@ -443,7 +445,7 @@ static void stellar_thread_clean(struct stellar *st)
struct stellar_runtime *runtime = &st->runtime; struct stellar_runtime *runtime = &st->runtime;
struct stellar_config *config = &st->config; struct stellar_config *config = &st->config;
STELLAR_LOG_FATAL("cleaning worker thread context ..."); CORE_LOG_FATAL("cleaning worker thread context ...");
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++) for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
{ {
struct stellar_thread *thread = &runtime->threads[i]; struct stellar_thread *thread = &runtime->threads[i];
@@ -454,7 +456,7 @@ static void stellar_thread_clean(struct stellar *st)
snowflake_free(thread->snowflake); snowflake_free(thread->snowflake);
} }
} }
STELLAR_LOG_FATAL("worker thread context cleaned"); CORE_LOG_FATAL("worker thread context cleaned");
} }
static int stellar_thread_run(struct stellar *st) static int stellar_thread_run(struct stellar *st)
@@ -467,7 +469,7 @@ static int stellar_thread_run(struct stellar *st)
struct stellar_thread *thread = &runtime->threads[i]; struct stellar_thread *thread = &runtime->threads[i];
if (pthread_create(&thread->tid, NULL, work_thread, (void *)thread) < 0) if (pthread_create(&thread->tid, NULL, work_thread, (void *)thread) < 0)
{ {
STELLAR_LOG_ERROR("unable to create worker thread, error %d: %s", errno, strerror(errno)); CORE_LOG_ERROR("unable to create worker thread, error %d: %s", errno, strerror(errno));
return -1; return -1;
} }
} }
@@ -480,7 +482,7 @@ static void stellar_thread_join(struct stellar *st)
struct stellar_runtime *runtime = &st->runtime; struct stellar_runtime *runtime = &st->runtime;
struct stellar_config *config = &st->config; struct stellar_config *config = &st->config;
STELLAR_LOG_FATAL("waiting worker thread stop ..."); CORE_LOG_FATAL("waiting worker thread stop ...");
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++) for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
{ {
struct stellar_thread *thread = &runtime->threads[i]; struct stellar_thread *thread = &runtime->threads[i];
@@ -489,7 +491,7 @@ static void stellar_thread_join(struct stellar *st)
usleep(1000); // 1ms usleep(1000); // 1ms
} }
} }
STELLAR_LOG_FATAL("all worker thread stoped"); CORE_LOG_FATAL("all worker thread stoped");
} }
struct stellar *stellar_new(const char *stellar_cfg_file, const char *plugin_cfg_file, const char *log_cfg_file) struct stellar *stellar_new(const char *stellar_cfg_file, const char *plugin_cfg_file, const char *log_cfg_file)
@@ -523,19 +525,21 @@ struct stellar *stellar_new(const char *stellar_cfg_file, const char *plugin_cfg
struct stellar_runtime *runtime = &st->runtime; struct stellar_runtime *runtime = &st->runtime;
struct stellar_config *config = &st->config; struct stellar_config *config = &st->config;
if (log_init(st->log_cfg_file) != 0) runtime->logger = log_new(st->log_cfg_file);
if (runtime->logger == NULL)
{ {
STELLAR_LOG_ERROR("unable to init log"); printf("unable to create logger");
goto error_out; goto error_out;
} }
STELLAR_LOG_FATAL("stellar start (version: %s)\n %s", version, logo_str); __thread_local_logger = runtime->logger;
STELLAR_LOG_FATAL("stellar config file : %s", st->stellar_cfg_file); CORE_LOG_FATAL("stellar start (version: %s)\n %s", version, logo_str);
STELLAR_LOG_FATAL("plugin config file : %s", st->plugin_cfg_file); CORE_LOG_FATAL("stellar config file : %s", st->stellar_cfg_file);
STELLAR_LOG_FATAL("log config file : %s", st->log_cfg_file); CORE_LOG_FATAL("plugin config file : %s", st->plugin_cfg_file);
CORE_LOG_FATAL("log config file : %s", st->log_cfg_file);
if (stellar_config_load(config, st->stellar_cfg_file) != 0) if (stellar_config_load(config, st->stellar_cfg_file) != 0)
{ {
STELLAR_LOG_ERROR("unable to load config file"); CORE_LOG_ERROR("unable to load config file");
goto error_out; goto error_out;
} }
stellar_config_print(config); stellar_config_print(config);
@@ -543,26 +547,26 @@ struct stellar *stellar_new(const char *stellar_cfg_file, const char *plugin_cfg
runtime->stat = stellar_stat_new(config->pkt_io_opts.nr_threads); runtime->stat = stellar_stat_new(config->pkt_io_opts.nr_threads);
if (runtime->stat == NULL) if (runtime->stat == NULL)
{ {
STELLAR_LOG_ERROR("unable to create stellar stat"); CORE_LOG_ERROR("unable to create stellar stat");
goto error_out; goto error_out;
} }
runtime->plug_mgr = plugin_manager_init(st, st->plugin_cfg_file); runtime->plug_mgr = plugin_manager_init(st, st->plugin_cfg_file);
if (runtime->plug_mgr == NULL) if (runtime->plug_mgr == NULL)
{ {
STELLAR_LOG_ERROR("unable to create plugin manager"); CORE_LOG_ERROR("unable to create plugin manager");
goto error_out; goto error_out;
} }
runtime->packet_io = packet_io_new(&config->pkt_io_opts); runtime->packet_io = packet_io_new(&config->pkt_io_opts);
if (runtime->packet_io == NULL) if (runtime->packet_io == NULL)
{ {
STELLAR_LOG_ERROR("unable to create packet io"); CORE_LOG_ERROR("unable to create packet io");
goto error_out; goto error_out;
} }
if (stellar_thread_init(st) != 0) if (stellar_thread_init(st) != 0)
{ {
STELLAR_LOG_ERROR("unable to init thread context"); CORE_LOG_ERROR("unable to init thread context");
goto error_out; goto error_out;
} }
@@ -590,7 +594,7 @@ void stellar_run(struct stellar *st)
if (stellar_thread_run(st) != 0) if (stellar_thread_run(st) != 0)
{ {
STELLAR_LOG_ERROR("unable to create worker thread"); CORE_LOG_ERROR("unable to create worker thread");
return; return;
} }
@@ -607,7 +611,7 @@ void stellar_run(struct stellar *st)
// only available in dump file mode, automatically exits when all sessions have been released // only available in dump file mode, automatically exits when all sessions have been released
if (packet_io_isbreak(runtime->packet_io) && all_session_have_freed(runtime, config)) if (packet_io_isbreak(runtime->packet_io) && all_session_have_freed(runtime, config))
{ {
STELLAR_LOG_FATAL("all sessions have been released, notify threads to exit"); CORE_LOG_FATAL("all sessions have been released, notify threads to exit");
stellar_stat_output(runtime->stat); // flush stat stellar_stat_output(runtime->stat); // flush stat
ATOMIC_SET(&runtime->need_exit, 1); ATOMIC_SET(&runtime->need_exit, 1);
} }
@@ -625,8 +629,8 @@ void stellar_free(struct stellar *st)
packet_io_free(runtime->packet_io); packet_io_free(runtime->packet_io);
plugin_manager_exit(runtime->plug_mgr); plugin_manager_exit(runtime->plug_mgr);
stellar_stat_free(runtime->stat); stellar_stat_free(runtime->stat);
STELLAR_LOG_FATAL("stellar exit\n"); CORE_LOG_FATAL("stellar exit\n");
log_free(); log_free(runtime->logger);
free(st); free(st);
st = NULL; st = NULL;
@@ -646,7 +650,7 @@ void stellar_reload_log_level(struct stellar *st)
{ {
if (st) if (st)
{ {
log_level_reload(st->log_cfg_file); log_level_reload(st->runtime.logger);
} }
} }
@@ -726,4 +730,16 @@ void stellar_send_build_packet(struct stellar *st, struct packet *pkt)
int stellar_get_worker_thread_num(struct stellar *st) int stellar_get_worker_thread_num(struct stellar *st)
{ {
return st->config.pkt_io_opts.nr_threads; return st->config.pkt_io_opts.nr_threads;
}
struct logger *stellar_get_logger(struct stellar *st)
{
if (st)
{
return st->runtime.logger;
}
else
{
return NULL;
}
} }

4
src/core/stellar_stat.cpp
View File

@@ -5,12 +5,12 @@
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
#include "log.h" #include "log_private.h"
#include "stellar_stat.h" #include "stellar_stat.h"
#include "fieldstat/fieldstat_easy.h" #include "fieldstat/fieldstat_easy.h"
#include "fieldstat/fieldstat_exporter.h" #include "fieldstat/fieldstat_exporter.h"
#define STAT_LOG_ERROR(format, ...) LOG_ERROR("stat", format, ##__VA_ARGS__) #define STAT_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "stat", format, ##__VA_ARGS__)
#define IS_FREE 0 #define IS_FREE 0
#define IS_BUSY 0xf #define IS_BUSY 0xf

1
src/core/version.map
View File

@@ -61,6 +61,7 @@ global:
stellar_run; stellar_run;
stellar_free; stellar_free;
stellar_loopbreak; stellar_loopbreak;
stellar_get_logger;
http_message_*; http_message_*;
http_decoder_init; http_decoder_init;

10
src/ip_reassembly/ip_reassembly.cpp
View File

@@ -3,16 +3,16 @@
#include <sys/queue.h> #include <sys/queue.h>
#include <assert.h> #include <assert.h>
#include "log.h"
#include "checksum.h" #include "checksum.h"
#include "crc32_hash.h" #include "crc32_hash.h"
#include "packet_private.h" #include "log_private.h"
#include "ip_reassembly.h"
#include "packet_parser.h" #include "packet_parser.h"
#include "packet_helper.h" #include "packet_helper.h"
#include "ip_reassembly.h" #include "packet_private.h"
#define IP_REASSEMBLE_DEBUG(format, ...) LOG_DEBUG("ip_reassembly", format, ##__VA_ARGS__) #define IP_REASSEMBLE_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "ip_reassembly", format, ##__VA_ARGS__)
#define IP_REASSEMBLE_ERROR(format, ...) LOG_ERROR("ip_reassembly", format, ##__VA_ARGS__) #define IP_REASSEMBLE_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "ip_reassembly", format, ##__VA_ARGS__)
#define IPV4_KEYLEN 1 #define IPV4_KEYLEN 1
#define IPV6_KEYLEN 4 #define IPV6_KEYLEN 4

2
src/log/CMakeLists.txt
View File

@@ -1,5 +1,7 @@
add_library(log log.cpp) add_library(log log.cpp)
target_include_directories(log PUBLIC ${CMAKE_CURRENT_LIST_DIR}) target_include_directories(log PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(log PUBLIC ${CMAKE_SOURCE_DIR}/include)
target_link_libraries(log toml) target_link_libraries(log toml)
add_subdirectory(test) add_subdirectory(test)

156
src/log/log.cpp
View File

@@ -1,5 +1,7 @@
#include <fcntl.h> #include <time.h>
#include <stdio.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <stdarg.h> #include <stdarg.h>
@@ -7,8 +9,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
#include "log.h"
#include "toml.h" #include "toml.h"
#include "log_private.h"
enum log_output enum log_output
{ {
@@ -24,39 +26,38 @@ struct log_config
char log_file[PATH_MAX]; char log_file[PATH_MAX];
}; };
struct log_context struct logger
{ {
char config_file[PATH_MAX];
struct log_config config; struct log_config config;
int log_fd; int log_fd;
int log_file_reopen_day; int log_file_opened_day;
}; };
struct log_context g_log_context = { static unsigned char level_str[6][6] = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
.config = {},
.log_fd = -1,
.log_file_reopen_day = 0,
};
struct log_context *g_log_ctx = &g_log_context;
static unsigned char weekday_str[7][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; static unsigned char weekday_str[7][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
static unsigned char month_str[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; static unsigned char month_str[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
static unsigned char level_str[7][6] = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "STATE"};
static inline void local_time(struct tm *local) thread_local struct logger *__thread_local_logger;
/******************************************************************************
* Private API
******************************************************************************/
static void local_time(struct tm *local)
{ {
time_t t; time_t t;
time(&t); time(&t);
localtime_r(&t, local); localtime_r(&t, local);
} }
static inline enum log_level check_level(const char *level) static int str_to_level(const char *level)
{ {
if (level == NULL) if (level == NULL)
{ {
return LOG_NONE; return -1;
} }
if (strcasecmp(level, "TRACE") == 0) if (strcasecmp(level, "TRACE") == 0)
{ {
return LOG_TRACE; return LOG_TRACE;
@@ -83,13 +84,11 @@ static inline enum log_level check_level(const char *level)
} }
else else
{ {
return LOG_NONE; return -1;
} }
} }
// return 0: success static int config_parse(struct log_config *config, const char *config_file)
// return -1: failed
static int parse_config(struct log_config *config, const char *cfg_file)
{ {
int ret = -1; int ret = -1;
FILE *fp = NULL; FILE *fp = NULL;
@@ -101,32 +100,31 @@ static int parse_config(struct log_config *config, const char *cfg_file)
toml_table_t *section = NULL; toml_table_t *section = NULL;
toml_table_t *table = NULL; toml_table_t *table = NULL;
fp = fopen(cfg_file, "r"); fp = fopen(config_file, "r");
if (fp == NULL) if (fp == NULL)
{ {
fprintf(stderr, "open config file %s failed, %s\n", cfg_file, strerror(errno)); fprintf(stderr, "(logger) open config file %s failed, %s\n", config_file, strerror(errno));
goto error_out; goto error_out;
} }
table = toml_parse_file(fp, errbuf, sizeof(errbuf)); table = toml_parse_file(fp, errbuf, sizeof(errbuf));
if (table == NULL) if (table == NULL)
{ {
fprintf(stderr, "parse config file %s failed, %s\n", cfg_file, errbuf); fprintf(stderr, "(logger) parse config file %s failed, %s\n", config_file, errbuf);
goto error_out; goto error_out;
} }
section = toml_table_in(table, "log"); section = toml_table_in(table, "log");
if (section == NULL) if (section == NULL)
{ {
fprintf(stderr, "config file %s missing log section\n", cfg_file); fprintf(stderr, "(logger) config file %s missing log section\n", config_file);
goto error_out; goto error_out;
} }
// output
ptr = toml_raw_in(section, "output"); ptr = toml_raw_in(section, "output");
if (ptr == NULL || toml_rtos(ptr, &ptr_output) != 0) if (ptr == NULL || toml_rtos(ptr, &ptr_output) != 0)
{ {
fprintf(stderr, "config file %s missing log.output\n", cfg_file); fprintf(stderr, "(logger) config file %s missing log.output\n", config_file);
goto error_out; goto error_out;
} }
if (strcasecmp(ptr_output, "stderr") == 0) if (strcasecmp(ptr_output, "stderr") == 0)
@@ -143,7 +141,7 @@ static int parse_config(struct log_config *config, const char *cfg_file)
} }
else else
{ {
fprintf(stderr, "config file %s invalid log.output\n", cfg_file); fprintf(stderr, "(logger) config file %s invalid log.output\n", config_file);
goto error_out; goto error_out;
} }
@@ -152,30 +150,28 @@ static int parse_config(struct log_config *config, const char *cfg_file)
ptr = toml_raw_in(section, "file"); ptr = toml_raw_in(section, "file");
if (ptr == NULL || toml_rtos(ptr, &ptr_file) != 0) if (ptr == NULL || toml_rtos(ptr, &ptr_file) != 0)
{ {
fprintf(stderr, "config file %s missing log.file\n", cfg_file); fprintf(stderr, "(logger) config file %s missing log.file\n", config_file);
goto error_out; goto error_out;
} }
strcpy(config->log_file, ptr_file); strcpy(config->log_file, ptr_file);
} }
// level
ptr = toml_raw_in(section, "level"); ptr = toml_raw_in(section, "level");
if (ptr == NULL || toml_rtos(ptr, &ptr_level) != 0) if (ptr == NULL || toml_rtos(ptr, &ptr_level) != 0)
{ {
fprintf(stderr, "config file %s missing log.level\n", cfg_file); fprintf(stderr, "(logger) config file %s missing log.level\n", config_file);
goto error_out; goto error_out;
} }
config->level = check_level(ptr_level); config->level = (enum log_level)str_to_level(ptr_level);
if (config->level == LOG_NONE) if (config->level == -1)
{ {
fprintf(stderr, "config file %s invalid log.level\n", cfg_file); fprintf(stderr, "config file %s invalid log.level\n", config_file);
goto error_out; goto error_out;
} }
ret = 0; ret = 0;
error_out: error_out:
if (ptr_output) if (ptr_output)
{ {
free(ptr_output); free(ptr_output);
@@ -200,27 +196,25 @@ error_out:
return ret; return ret;
} }
// return 0: success static int log_file_reopen(struct logger *logger)
// return -1: failed
static int log_reopen()
{ {
int new_fd; int new_fd;
int old_fd; int old_fd;
struct tm local; struct tm local;
char buff[PATH_MAX * 2] = {0}; char buff[PATH_MAX * 2] = {0};
local_time(&local); local_time(&local);
snprintf(buff, sizeof(buff), "%s.%d-%02d-%02d", g_log_ctx->config.log_file, local.tm_year + 1900, local.tm_mon + 1, local.tm_mday); snprintf(buff, sizeof(buff), "%s.%d-%02d-%02d", logger->config.log_file, local.tm_year + 1900, local.tm_mon + 1, local.tm_mday);
new_fd = open(buff, O_WRONLY | O_APPEND | O_CREAT, 0644); new_fd = open(buff, O_WRONLY | O_APPEND | O_CREAT, 0644);
if (new_fd == -1) if (new_fd == -1)
{ {
fprintf(stderr, "open() \"%s\" failed, %s\n", buff, strerror(errno)); fprintf(stderr, "(logger) open() \"%s\" failed, %s\n", buff, strerror(errno));
return -1; return -1;
} }
g_log_ctx->log_file_reopen_day = local.tm_mday; logger->log_file_opened_day = local.tm_mday;
old_fd = g_log_ctx->log_fd; old_fd = logger->log_fd;
g_log_ctx->log_fd = new_fd; logger->log_fd = new_fd;
if (old_fd > 0) if (old_fd > 0)
{ {
@@ -234,56 +228,74 @@ static int log_reopen()
* Public API * Public API
******************************************************************************/ ******************************************************************************/
// return 0: success struct logger *log_new(const char *config_file)
// return -1: failed
int log_init(const char *config_file)
{ {
memset(g_log_ctx, 0, sizeof(struct log_context)); struct logger *logger = (struct logger *)calloc(1, sizeof(struct logger));
if (logger == NULL)
if (parse_config(&g_log_ctx->config, config_file) != 0)
{ {
return -1; fprintf(stderr, "(logger) logger calloc() failed, %s\n", strerror(errno));
return NULL;
} }
if (g_log_context.config.output == LOG_OUTPUT_FILE || g_log_context.config.output == LOG_OUTPUT_BOTH) memcpy(&logger->config_file, config_file, strlen(config_file));
if (config_parse(&logger->config, config_file) != 0)
{ {
if (log_reopen() != 0) goto error_out;
}
if (logger->config.output == LOG_OUTPUT_FILE || logger->config.output == LOG_OUTPUT_BOTH)
{
if (log_file_reopen(logger) != 0)
{ {
return -1; goto error_out;
} }
} }
return 0; return logger;
error_out:
log_free(logger);
return NULL;
} }
void log_free() void log_free(struct logger *logger)
{ {
if (g_log_ctx->config.output == LOG_OUTPUT_FILE || g_log_ctx->config.output == LOG_OUTPUT_BOTH) if (logger)
{ {
if (g_log_ctx->log_fd > 0) if (logger->config.output == LOG_OUTPUT_FILE || logger->config.output == LOG_OUTPUT_BOTH)
{ {
close(g_log_ctx->log_fd); if (logger->log_fd > 0)
g_log_ctx->log_fd = -1; {
close(logger->log_fd);
logger->log_fd = -1;
}
} }
free(logger);
logger = NULL;
} }
} }
int log_level_check(enum log_level level) int log_level_check(struct logger *logger, enum log_level level)
{ {
return level >= g_log_ctx->config.level; return level >= logger->config.level;
} }
void log_level_reload(const char *config_file) void log_level_reload(struct logger *logger)
{ {
struct log_config config; struct log_config config = {};
if (parse_config(&config, config_file) != 0) if (config_parse(&config, logger->config_file) == 0)
{ {
return; logger->config.level = config.level;
fprintf(stderr, "(logger) logger level reload to %s\n", level_str[config.level]);
}
else
{
fprintf(stderr, "(logger) logger level reload failed\n");
} }
g_log_context.config.level = config.level;
} }
void log_print(enum log_level level, const char *module, const char *fmt, ...) void log_print(struct logger *logger, enum log_level level, const char *module, const char *fmt, ...)
{ {
int nwrite; int nwrite;
char buf[4096] = {0}; char buf[4096] = {0};
@@ -309,20 +321,20 @@ void log_print(enum log_level level, const char *module, const char *fmt, ...)
// add end of line // add end of line
p += snprintf(p, end - p, "\n"); p += snprintf(p, end - p, "\n");
if (g_log_ctx->config.output == LOG_OUTPUT_STDERR || g_log_ctx->config.output == LOG_OUTPUT_BOTH) if (logger->config.output == LOG_OUTPUT_STDERR || logger->config.output == LOG_OUTPUT_BOTH)
{ {
fprintf(stderr, "%s", buf); fprintf(stderr, "%s", buf);
} }
if (g_log_ctx->config.output == LOG_OUTPUT_FILE || g_log_ctx->config.output == LOG_OUTPUT_BOTH) if (logger->config.output == LOG_OUTPUT_FILE || logger->config.output == LOG_OUTPUT_BOTH)
{ {
if (g_log_ctx->log_file_reopen_day != local.tm_mday) if (logger->log_file_opened_day != local.tm_mday)
{ {
log_reopen(); log_file_reopen(logger);
} }
do do
{ {
nwrite = write(g_log_ctx->log_fd, buf, p - buf); nwrite = write(logger->log_fd, buf, p - buf);
} while (nwrite == -1 && errno == EINTR); } while (nwrite == -1 && errno == EINTR);
} }
} }

66
src/log/log.h
View File

@@ -1,66 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
enum log_level
{
LOG_NONE = -1,
LOG_TRACE = 0,
LOG_DEBUG = 1,
LOG_INFO = 2,
LOG_WARN = 3,
LOG_ERROR = 4,
LOG_FATAL = 5,
};
#define LOG_TRACE(module, format, ...) \
if (log_level_check(LOG_TRACE)) \
{ \
log_print(LOG_TRACE, module, format, ##__VA_ARGS__); \
}
#define LOG_DEBUG(module, format, ...) \
if (log_level_check(LOG_DEBUG)) \
{ \
log_print(LOG_DEBUG, module, format, ##__VA_ARGS__); \
}
#define LOG_INFO(module, format, ...) \
if (log_level_check(LOG_INFO)) \
{ \
log_print(LOG_INFO, module, format, ##__VA_ARGS__); \
}
#define LOG_WARN(module, format, ...) \
if (log_level_check(LOG_WARN)) \
{ \
log_print(LOG_WARN, module, format, ##__VA_ARGS__); \
}
#define LOG_ERROR(module, format, ...) \
if (log_level_check(LOG_ERROR)) \
{ \
log_print(LOG_ERROR, module, format, ##__VA_ARGS__); \
}
#define LOG_FATAL(module, format, ...) \
if (log_level_check(LOG_FATAL)) \
{ \
log_print(LOG_FATAL, module, format, ##__VA_ARGS__); \
}
// return 0: success
// return -1: failed
int log_init(const char *config_file);
void log_free();
int log_level_check(enum log_level level);
void log_level_reload(const char *config_file);
void log_print(enum log_level level, const char *module, const char *fmt, ...);
#ifdef __cplusplus
}
#endif

18
src/log/log_private.h Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include "stellar/log.h"
extern thread_local struct logger *__thread_local_logger;
struct logger *log_new(const char *config_file);
void log_free(struct logger *logger);
void log_level_reload(struct logger *logger);
#ifdef __cplusplus
}
#endif

78
src/log/test/gtest_log.cpp
View File

@@ -1,6 +1,6 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "log.h" #include "log_private.h"
#if 1 #if 1
TEST(LOG, STDERR) TEST(LOG, STDERR)
@@ -8,26 +8,27 @@ TEST(LOG, STDERR)
char buffer[1024] = {0}; char buffer[1024] = {0};
const char *config = "./conf/log_stderr.toml"; const char *config = "./conf/log_stderr.toml";
snprintf(buffer, sizeof(buffer), "sed -i 's/DEBUG/ERROR/g' %s", config); snprintf(buffer, sizeof(buffer), "sed -i 's/DEBUG/ERROR/g' %s", config);
EXPECT_TRUE(log_init(config) == 0); struct logger *logger = log_new(config);
EXPECT_TRUE(logger);
LOG_TRACE("test", "test log 1"); STELLAR_LOG_TRACE(logger, "test", "test log 1");
LOG_DEBUG("test", "test log 1"); STELLAR_LOG_DEBUG(logger, "test", "test log 1");
LOG_INFO("test", "test log 1"); STELLAR_LOG_INFO(logger, "test", "test log 1");
LOG_WARN("test", "test log 1"); STELLAR_LOG_WARN(logger, "test", "test log 1");
LOG_ERROR("test", "test log 1"); STELLAR_LOG_ERROR(logger, "test", "test log 1");
LOG_FATAL("test", "test log 1"); STELLAR_LOG_FATAL(logger, "test", "test log 1");
system(buffer); system(buffer);
log_level_reload(config); log_level_reload(logger);
LOG_TRACE("test", "test log 2"); STELLAR_LOG_TRACE(logger, "test", "test log 2");
LOG_DEBUG("test", "test log 2"); STELLAR_LOG_DEBUG(logger, "test", "test log 2");
LOG_INFO("test", "test log 2"); STELLAR_LOG_INFO(logger, "test", "test log 2");
LOG_WARN("test", "test log 2"); STELLAR_LOG_WARN(logger, "test", "test log 2");
LOG_ERROR("test", "test log 2"); STELLAR_LOG_ERROR(logger, "test", "test log 2");
LOG_FATAL("test", "test log 2"); STELLAR_LOG_FATAL(logger, "test", "test log 2");
log_free(); log_free(logger);
} }
#endif #endif
@@ -37,26 +38,27 @@ TEST(LOG, FILE)
char buffer[1024] = {0}; char buffer[1024] = {0};
const char *config = "./conf/log_file.toml"; const char *config = "./conf/log_file.toml";
snprintf(buffer, sizeof(buffer), "sed -i 's/DEBUG/ERROR/g' %s", config); snprintf(buffer, sizeof(buffer), "sed -i 's/DEBUG/ERROR/g' %s", config);
EXPECT_TRUE(log_init(config) == 0); struct logger *logger = log_new(config);
EXPECT_TRUE(logger);
LOG_TRACE("test", "test log 1"); STELLAR_LOG_TRACE(logger, "test", "test log 1");
LOG_DEBUG("test", "test log 1"); STELLAR_LOG_DEBUG(logger, "test", "test log 1");
LOG_INFO("test", "test log 1"); STELLAR_LOG_INFO(logger, "test", "test log 1");
LOG_WARN("test", "test log 1"); STELLAR_LOG_WARN(logger, "test", "test log 1");
LOG_ERROR("test", "test log 1"); STELLAR_LOG_ERROR(logger, "test", "test log 1");
LOG_FATAL("test", "test log 1"); STELLAR_LOG_FATAL(logger, "test", "test log 1");
system(buffer); system(buffer);
log_level_reload(config); log_level_reload(logger);
LOG_TRACE("test", "test log 2"); STELLAR_LOG_TRACE(logger, "test", "test log 2");
LOG_DEBUG("test", "test log 2"); STELLAR_LOG_DEBUG(logger, "test", "test log 2");
LOG_INFO("test", "test log 2"); STELLAR_LOG_INFO(logger, "test", "test log 2");
LOG_WARN("test", "test log 2"); STELLAR_LOG_WARN(logger, "test", "test log 2");
LOG_ERROR("test", "test log 2"); STELLAR_LOG_ERROR(logger, "test", "test log 2");
LOG_FATAL("test", "test log 2"); STELLAR_LOG_FATAL(logger, "test", "test log 2");
log_free(); log_free(logger);
} }
#endif #endif
@@ -75,12 +77,12 @@ TEST(LOG, REOPEN)
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
{ {
LOG_TRACE("test", "test log %d", i); STELLAR_LOG_TRACE(logger, "test", "test log %d", i);
LOG_DEBUG("test", "test log %d", i); STELLAR_LOG_DEBUG(logger, "test", "test log %d", i);
LOG_INFO("test", "test log %d", i); STELLAR_LOG_INFO(logger, "test", "test log %d", i);
LOG_WARN("test", "test log %d", i); STELLAR_LOG_WARN(logger, "test", "test log %d", i);
LOG_ERROR("test", "test log %d", i); STELLAR_LOG_ERROR(logger, "test", "test log %d", i);
LOG_FATAL("test", "test log %d", i); STELLAR_LOG_FATAL(logger, "test", "test log %d", i);
if (i == 1) if (i == 1)
{ {
system(buffer2); // set date to 2099/01/01 system(buffer2); // set date to 2099/01/01
@@ -91,7 +93,7 @@ TEST(LOG, REOPEN)
} }
} }
log_free(); log_free(logger);
} }
#endif #endif

8
src/packet/packet_builder.cpp
View File

@@ -1,13 +1,13 @@
#include <time.h> #include <time.h>
#include "log.h"
#include "checksum.h" #include "checksum.h"
#include "packet_private.h" #include "log_private.h"
#include "packet_helper.h" #include "packet_helper.h"
#include "packet_parser.h" #include "packet_parser.h"
#include "packet_private.h"
#define PACKET_CRAFT_LOG_DEBUG(format, ...) LOG_DEBUG("packet craft", format, ##__VA_ARGS__) #define PACKET_CRAFT_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "packet craft", format, ##__VA_ARGS__)
#define PACKET_CRAFT_LOG_ERROR(format, ...) LOG_ERROR("packet craft", format, ##__VA_ARGS__) #define PACKET_CRAFT_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "packet craft", format, ##__VA_ARGS__)
struct fingerprint struct fingerprint
{ {

8
src/packet/packet_dump.cpp
View File

@@ -4,14 +4,14 @@
#include <string.h> #include <string.h>
#include <sys/time.h> #include <sys/time.h>
#include "log.h"
#include "utils.h" #include "utils.h"
#include "packet_helper.h" #include "log_private.h"
#include "packet_private.h"
#include "packet_dump.h" #include "packet_dump.h"
#include "packet_parser.h" #include "packet_parser.h"
#include "packet_helper.h"
#include "packet_private.h"
#define PACKET_DUMP_LOG_ERROR(format, ...) LOG_ERROR("packet dump", format, ##__VA_ARGS__) #define PACKET_DUMP_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "packet dump", format, ##__VA_ARGS__)
struct pcap_pkt_hdr struct pcap_pkt_hdr
{ {

8
src/packet/packet_parser.cpp
View File

@@ -4,14 +4,14 @@
#include <netinet/ip_icmp.h> #include <netinet/ip_icmp.h>
#include <linux/ppp_defs.h> #include <linux/ppp_defs.h>
#include "log.h" #include "log_private.h"
#include "packet_helper.h" #include "packet_helper.h"
#include "packet_private.h" #include "packet_private.h"
#include "packet_parser.h" #include "packet_parser.h"
#define PACKET_PARSE_LOG_DEBUG(format, ...) void(0) // LOG_DEBUG("packet parse", format, ##__VA_ARGS__) #define PACKET_PARSE_LOG_DEBUG(format, ...) void(0) // STELLAR_LOG_DEBUG(__thread_local_logger, "packet parse", format, ##__VA_ARGS__)
#define PACKET_PARSE_LOG_WARN(format, ...) LOG_WARN("packet parse", format, ##__VA_ARGS__) #define PACKET_PARSE_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "packet parse", format, ##__VA_ARGS__)
#define PACKET_PARSE_LOG_ERROR(format, ...) LOG_ERROR("packet parse", format, ##__VA_ARGS__) #define PACKET_PARSE_LOG_WARN(format, ...) STELLAR_LOG_WARN(__thread_local_logger, "packet parse", format, ##__VA_ARGS__)
#define PACKET_LOG_DATA_INSUFFICIENCY(pkt, layer) \ #define PACKET_LOG_DATA_INSUFFICIENCY(pkt, layer) \
{ \ { \

2
src/packet/packet_parser.h
View File

@@ -5,6 +5,8 @@ extern "C"
{ {
#endif #endif
#include "stellar/packet.h"
const char *packet_parse(struct packet *pkt, const char *data, uint16_t len); const char *packet_parse(struct packet *pkt, const char *data, uint16_t len);
const char *layer_proto_to_str(enum layer_proto proto); const char *layer_proto_to_str(enum layer_proto proto);

4
src/packet/packet_utils.cpp
View File

@@ -1,10 +1,10 @@
#include "log.h"
#include "tuple.h" #include "tuple.h"
#include "uthash.h" #include "uthash.h"
#include "log_private.h"
#include "packet_helper.h" #include "packet_helper.h"
#include "packet_private.h" #include "packet_private.h"
#define PACKET_LOG_ERROR(format, ...) LOG_ERROR("packet", format, ##__VA_ARGS__) #define PACKET_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "packet", format, ##__VA_ARGS__)
/****************************************************************************** /******************************************************************************
* metadata utils * metadata utils

10
src/packet_io/dumpfile_io.cpp
View File

@@ -9,16 +9,16 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include "log.h"
#include "tuple.h" #include "tuple.h"
#include "utils.h" #include "utils.h"
#include "log_private.h"
#include "dumpfile_io.h" #include "dumpfile_io.h"
#include "packet_private.h"
#include "packet_parser.h"
#include "packet_dump.h" #include "packet_dump.h"
#include "packet_parser.h"
#include "packet_private.h"
#define PACKET_IO_LOG_FATAL(format, ...) LOG_FATAL("dumpfile", format, ##__VA_ARGS__) #define PACKET_IO_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "dumpfile", format, ##__VA_ARGS__)
#define PACKET_IO_LOG_ERROR(format, ...) LOG_ERROR("dumpfile", format, ##__VA_ARGS__) #define PACKET_IO_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "dumpfile", format, ##__VA_ARGS__)
#define MAX_PACKET_QUEUE_SIZE (4096 * 1000) #define MAX_PACKET_QUEUE_SIZE (4096 * 1000)

6
src/packet_io/marsio_io.cpp
View File

@@ -4,13 +4,13 @@
#include <string.h> #include <string.h>
#include <netinet/ether.h> #include <netinet/ether.h>
#include "log.h"
#include "marsio.h" #include "marsio.h"
#include "marsio_io.h" #include "marsio_io.h"
#include "packet_private.h" #include "log_private.h"
#include "packet_parser.h" #include "packet_parser.h"
#include "packet_private.h"
#define PACKET_IO_LOG_ERROR(format, ...) LOG_ERROR("marsio", format, ##__VA_ARGS__) #define PACKET_IO_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "marsio", format, ##__VA_ARGS__)
struct marsio_io struct marsio_io
{ {

6
src/session/session_manager.cpp
View File

@@ -2,8 +2,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include "log.h"
#include "utils.h" #include "utils.h"
#include "log_private.h"
#include "packet_helper.h" #include "packet_helper.h"
#include "packet_filter.h" #include "packet_filter.h"
#include "session_private.h" #include "session_private.h"
@@ -14,8 +14,8 @@
#include "session_manager.h" #include "session_manager.h"
#include "session_transition.h" #include "session_transition.h"
#define SESSION_LOG_ERROR(format, ...) LOG_ERROR("session", format, ##__VA_ARGS__) #define SESSION_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session", format, ##__VA_ARGS__)
#define SESSION_LOG_DEBUG(format, ...) LOG_DEBUG("session", format, ##__VA_ARGS__) #define SESSION_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session", format, ##__VA_ARGS__)
struct session_manager struct session_manager
{ {

4
src/session/session_transition.cpp
View File

@@ -1,11 +1,11 @@
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
#include "log.h" #include "log_private.h"
#include "session_private.h" #include "session_private.h"
#include "session_transition.h" #include "session_transition.h"
#define SESSION_TRANSITION_LOG_INFO(format, ...) LOG_INFO("session transition", format, ##__VA_ARGS__) #define SESSION_TRANSITION_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session transition", format, ##__VA_ARGS__)
#define MAX_TRANSITION_PER_STATE 8 #define MAX_TRANSITION_PER_STATE 8

4
src/snowflake/snowflake.cpp
View File

@@ -1,10 +1,10 @@
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include "log.h"
#include "snowflake.h" #include "snowflake.h"
#include "log_private.h"
#define SNOWFLAKE_LOG_ERROR(format, ...) LOG_ERROR("snowflake", format, ##__VA_ARGS__) #define SNOWFLAKE_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "snowflake", format, ##__VA_ARGS__)
struct snowflake struct snowflake
{ {

6
src/tcp_reassembly/tcp_reassembly.cpp
View File

@@ -1,13 +1,13 @@
#include <string.h> #include <string.h>
#include "log.h"
#include "list.h" #include "list.h"
#include "log_private.h"
#include "interval_tree.h" #include "interval_tree.h"
#include "tcp_reassembly.h" #include "tcp_reassembly.h"
#include "stellar/stellar.h" #include "stellar/stellar.h"
#define TCP_REASSEMBLY_LOG_DEBUG(format, ...) LOG_DEBUG("tcp_reassembly", format, ##__VA_ARGS__) #define TCP_REASSEMBLY_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "tcp_reassembly", format, ##__VA_ARGS__)
#define TCP_REASSEMBLY_LOG_ERROR(format, ...) LOG_ERROR("tcp_reassembly", format, ##__VA_ARGS__) #define TCP_REASSEMBLY_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "tcp_reassembly", format, ##__VA_ARGS__)
struct tcp_segment_private struct tcp_segment_private
{ {

5
test/debug_plugin/debug_plugin.cpp
View File

@@ -7,6 +7,7 @@
#include "utils.h" #include "utils.h"
#include "packet_dump.h" #include "packet_dump.h"
#include "session_private.h" #include "session_private.h"
#include "stellar/log.h"
#include "stellar/stellar_mq.h" #include "stellar/stellar_mq.h"
#include "stellar/stellar_exdata.h" #include "stellar/stellar_exdata.h"
@@ -51,6 +52,7 @@ static void log_print(int fd, const char *module, const char *fmt, ...)
struct plugin_ctx struct plugin_ctx
{ {
struct stellar *st; struct stellar *st;
struct logger *logger;
int sess_exdata_idx; int sess_exdata_idx;
int sess_plug_id; int sess_plug_id;
int tcp_topic_id; int tcp_topic_id;
@@ -271,6 +273,7 @@ extern "C"
pthread_spin_init(&ctx->lock, PTHREAD_PROCESS_PRIVATE); pthread_spin_init(&ctx->lock, PTHREAD_PROCESS_PRIVATE);
ctx->st = st; ctx->st = st;
ctx->logger = stellar_get_logger(st);
ctx->sess_exdata_idx = stellar_exdata_new_index(st, "DEBUG_PLUGIN_SESS_EXDATA", stellar_exdata_free_default, NULL); ctx->sess_exdata_idx = stellar_exdata_new_index(st, "DEBUG_PLUGIN_SESS_EXDATA", stellar_exdata_free_default, NULL);
ctx->sess_plug_id = stellar_session_plugin_register(st, on_sess_new, on_sess_free, ctx); ctx->sess_plug_id = stellar_session_plugin_register(st, on_sess_new, on_sess_free, ctx);
ctx->udp_topic_id = stellar_mq_get_topic_id(st, TOPIC_UDP); ctx->udp_topic_id = stellar_mq_get_topic_id(st, TOPIC_UDP);
@@ -281,6 +284,7 @@ extern "C"
stellar_session_mq_subscribe(st, ctx->tcp_topic_id, on_sess_tcp_msg, ctx->sess_plug_id); stellar_session_mq_subscribe(st, ctx->tcp_topic_id, on_sess_tcp_msg, ctx->sess_plug_id);
stellar_session_mq_subscribe(st, ctx->tcp_stream_topic_id, on_sess_tcp_stream_msg, ctx->sess_plug_id); stellar_session_mq_subscribe(st, ctx->tcp_stream_topic_id, on_sess_tcp_stream_msg, ctx->sess_plug_id);
STELLAR_LOG_FATAL(ctx->logger, "debug plugin", "init");
log_print(ctx->fd, "debug plugin", "init"); log_print(ctx->fd, "debug plugin", "init");
return ctx; return ctx;
@@ -291,6 +295,7 @@ extern "C"
struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx; struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
if (ctx) if (ctx)
{ {
STELLAR_LOG_FATAL(ctx->logger, "debug plugin", "exit");
log_print(ctx->fd, "debug plugin", "exit"); log_print(ctx->fd, "debug plugin", "exit");
if (ctx->fd > 0) if (ctx->fd > 0)
{ {