目录
线程类型
suricata 除了主线程外还有若干子线程，子线程类型见下表：
| 序号 | 线程类型 | name | 线程数量 | tv->type | tv->tm_func()对应的函数 | tv->tm_slots 对应的slot表（TmModule） | 备注 | |
| 1 | worker threads | W | suricata.yaml threading配置 | packetpool | TVT_PPT | TmThreadsSlotPktAcqLoop | Receive ->Decode->FlowWorker | |
| 2 | FlowManagerThread | FM | suricata.yaml flow.managers | management | TVT_MGMT | TmThreadsManagement | FlowManager | 默认为1个 |
| 3 | FlowRecyclerThread | FR | suricata.yaml flow.recyclers | management | TVT_MGMT | TmThreadsManagement | FlowRecycler | 默认为1个 |
| 4 | BypassedFlowManagerThread | FB | 1 | management | TVT_MGMT | TmThreadsManagement | BypassedFlowManager | |
| 5 | StatsWakeupThread | CW | 1 | custom | TVT_MGMT | StatsWakeupThread | 无 | |
| 6 | StatsMgmtThread | CS | 1 | custom | TVT_MGMT | StatsMgmtThread | 无 | |
| 7 | UnixManagerThread | US | 2 or 0 | command | TVT_CMD | TmThreadsManagement | UnixManager | RUNMODE_UNIX_SOCKET mode是才创建，否则没有 |
| 8 | DetectLoaderThread | DL | suricata.yaml multi-detect.loaders or 0 | command | TVT_CMD | TmThreadsManagement | DetectLoader | MT(多租户)被启用才创建，默认的配置没有此项。 |
0. 主线程
主线程函数： int main(int argc, char **argv)，可参见suricata 初始化做的那些事儿_xuwaiwai的博客-CSDN博客_suricata目录前言一、SuricataMain 程序入口1.在引擎中注册所有运行模式。2.解析执行命令3.初始化全局变量3.加载yaml配置文件4.初始化日志5.打印版本和CPUs/cores6.解析接口设置名称7.配置加载后的操作A. 设置多模和单模匹配模式B. 设置checksumC. 初始化存储模块D. 应用层协议设置E. 设置捕获参数F. 加载主机操作系统策略信息G. 初始化检测引擎H. 初始化queue handler（队列处理函数）https://blog.csdn.net/xuwaiwai/article/details/120045259?spm=1001.2014.3001.5501
注册runmodes
注册各种的运行模式到 runmodes 数据中（这里的运行模式是采集数据来源和IPS/IDS 的组合，比如 RUNMODE_PCAP_DEV，RUNMODE_NFQ，RUNMODE_AFP_DEV）， 在每个运行模式具体的注册函数中，分别注册各自支持的工作模式（"single"，"workers"，"autofp"），runmodes 结构如下。实际运行时会全部注册各种运行模式的工作模式，但是会根据运行命令和配置只会初始化并使用一种（运行模式 + 工作模式），如（RUNMODE_AFP_DEV+ "workers"）。
typedef struct RunMode_ { //每种工作模式
/* the runmode type */
enum RunModes runmode; //运行模式 RUNMODE_AFP_DEV
const char *name; //工作模式名字 "workers"
const char *description; //描述
/* runmode function */
int (*RunModeFunc)(void); //初始化的回调函数
} RunMode;
typedef struct RunModes_ {
int cnt;
RunMode *runmodes; //容纳多个工作模式(single, workers, autofp)
} RunModes;
static RunModes runmodes[RUNMODE_USER_MAX]; //容纳多种运行模式
//eg. （RUNMODE_AFP_DEV+ "workers"）将注册如下几种
void RunModeIdsAFPRegister(void)
{
RunModeRegisterNewRunMode(RUNMODE_AFP_DEV, "single",
"Single threaded af-packet mode",
RunModeIdsAFPSingle);
RunModeRegisterNewRunMode(RUNMODE_AFP_DEV, "workers",
"Workers af-packet mode, each thread does all"
" tasks from acquisition to logging",
RunModeIdsAFPWorkers);
RunModeRegisterNewRunMode(RUNMODE_AFP_DEV, "autofp",
"Multi socket AF_PACKET mode. Packets from "
"each flow are assigned to a single detect "
"thread.",
RunModeIdsAFPAutoFp);
return;
}
根据配置初始化
解析执行命令，记载 suricata.yaml配置文件，初始化日志系统。
注册应用协议检测器
：这个主要是根据相应的协议做对应的规则检测，初始化并保存在全局{static AppLayerProtoDetectCtx alpd_ctx}中。
多模：放入 MpmTableElmt mpm_table[MPM_TABLE_SIZE] 中，总共有四种， 分别注册一些回调函数。实际使用时根据配置只用一种。
enum {
MPM_NOTSET = 0,
/* aho-corasick */
MPM_AC,
MPM_AC_BS,
MPM_AC_KS,
MPM_HS,
/* table size */
MPM_TABLE_SIZE,
};
typedef struct MpmTableElmt_ {
const char *name;
void (*InitCtx)(struct MpmCtx_ *);
void (*InitThreadCtx)(struct MpmCtx_ *, struct MpmThreadCtx_ *);
void (*DestroyCtx)(struct MpmCtx_ *);
void (*DestroyThreadCtx)(struct MpmCtx_ *, struct MpmThreadCtx_ *);
int (*AddPattern)(struct MpmCtx_ *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int (*AddPatternNocase)(struct MpmCtx_ *, uint8_t *, uint16_t, uint16_t, uint16_t, uint32_t, SigIntId, uint8_t);
int (*Prepare)(struct MpmCtx_ *);
uint32_t (*Search)(const struct MpmCtx_ *, struct MpmThreadCtx_ *, PrefilterRuleStore *, const uint8_t *, uint32_t);
void (*PrintCtx)(struct MpmCtx_ *);
void (*PrintThreadCtx)(struct MpmThreadCtx_ *);
void (*RegisterUnittests)(void);
uint8_t flags;
} MpmTableElmt;
MpmTableElmt mpm_table[MPM_TABLE_SIZE];单模：放入 SpmTableElmt spm_table[SPM_TABLE_SIZE] 中;总共有两种，分别注册一些回调函数。实际使用时根据配置只用一种。
enum {
SPM_BM, /* Boyer-Moore */
SPM_HS, /* Hyperscan */
/* Other SPM matchers will go here. */
SPM_TABLE_SIZE
};
typedef struct SpmTableElmt_ {
const char *name;
SpmGlobalThreadCtx *(*InitGlobalThreadCtx)(void);
void (*DestroyGlobalThreadCtx)(SpmGlobalThreadCtx *g_thread_ctx);
SpmThreadCtx *(*MakeThreadCtx)(const SpmGlobalThreadCtx *g_thread_ctx);
void (*DestroyThreadCtx)(SpmThreadCtx *thread_ctx);
SpmCtx *(*InitCtx)(const uint8_t *needle, uint16_t needle_len, int nocase,
SpmGlobalThreadCtx *g_thread_ctx);
void (*DestroyCtx)(SpmCtx *);
uint8_t *(*Scan)(const SpmCtx *ctx, SpmThreadCtx *thread_ctx,
const uint8_t *haystack, uint32_t haystack_len);
} SpmTableElmt;
extern SpmTableElmt spm_table[SPM_TABLE_SIZE];根据配置中的匹配方式，初始化相应的单模和多模匹配，其中单模调用其中的 spm_table[matcher].InitGlobalThreadCtx() 回调函数来初始化，多模则会根据 三种协议（TCP,UDP,ICMP）和 两个方向（to_client, to_server）共六个组合分别初始化 mpm_table[matcher].InitCtx(mpm_ctx);
typedef struct AppLayerProtoDetectCtx_ {
/* Context per ip_proto.
* \todo Modify ctx_ipp to hold for only tcp and udp. The rest can be
* implemented if needed. Waste of space otherwise. */
AppLayerProtoDetectCtxIpproto ctx_ipp[FLOW_PROTO_DEFAULT]; //多模扫描
/* Global SPM thread context prototype. */
SpmGlobalThreadCtx *spm_global_thread_ctx; //单模扫描
AppLayerProtoDetectProbingParser *ctx_pp;
/* Indicates the protocols that have registered themselves
* for protocol detection. This table is independent of the
* ipproto. */
const char *alproto_names[ALPROTO_MAX];
} AppLayerProtoDetectCtx;
/* The global app layer proto detection context. */
static AppLayerProtoDetectCtx alpd_ctx;注册应用层协议解析器
：主要是根据应用协议做协议解析，注册各种协议的回调函数，分配相应内存并保存在全局{static AppLayerParserCtx alp_ctx}中
void AppLayerParserRegisterProtocolParsers(void)
{
SCEnter();
RegisterHTPParsers();
RegisterSSLParsers();
...
RegisterRdpParsers();
RegisterHTTP2Parsers();
/** IMAP */
AppLayerProtoDetectRegisterProtocol(ALPROTO_IMAP, "imap");
if (AppLayerProtoDetectConfProtoDetectionEnabled("tcp", "imap")) {
if (AppLayerProtoDetectPMRegisterPatternCS(IPPROTO_TCP, ALPROTO_IMAP,
"1|20|capability", 12, 0, STREAM_TOSERVER) < 0)
{
SCLogInfo("imap proto registration failure");
exit(EXIT_FAILURE);
}
} else {
SCLogInfo("Protocol detection and parser disabled for %s protocol.",
"imap");
}
ValidateParsers();
return;
}
加载规则关键字
：void SigTableSetup(void) 函数中执行，规则中各种关键字的注册，如sid, content, http.host 等。
void SigTableSetup(void)
{
memset(sigmatch_table, 0, sizeof(sigmatch_table));
DetectSidRegister();
...
DetectContentRegister();
DetectUricontentRegister();
/* NOTE: the order of these currently affects inspect
* engine registration order and ultimately the order
* of inspect engines in the rule. Which in turn affects
* state keeping */
DetectHttpUriRegister();
...
/* close keyword registration */
DetectBufferTypeCloseRegistration();
}
/* Table with all SigMatch registrations */
SigTableElmt sigmatch_table[DETECT_TBLSIZE];
初始化queue handler（队列处理函数），这个是衔接线程模块和数据包队列之间的桥梁，目前共有3 类handler：simple, packetpool, flow。每类handler内部都有一个InHandler和OutHandler，一个用于从上一级队列中获取数据包，另一个用于处理完毕后将数据包送入下一级队列。
enum {
TMQH_NOT_SET,
TMQH_SIMPLE,
TMQH_PACKETPOOL,
TMQH_FLOW,
TMQH_SIZE,
};
Tmqh tmqh_table[TMQH_SIZE];
void TmqhSetup (void)
{
memset(&tmqh_table, 0, sizeof(tmqh_table));
TmqhSimpleRegister();
TmqhPacketpoolRegister();
TmqhFlowRegister();
}tag初始化
tag作用：根据命中规则的tag信息分流或者是host记录前后的包数据，即标记规则命中之后的指定流量信息，用于指导日志对这些流量进行输出，方便分析（tag的作用和具体用法详情suricata源码之tag_村中少年的专栏-CSDN博客_suricata 源码分析）。
alter标记结构初始化：
/** tag signature we use for tag alerts */
static Signature g_tag_signature;
/** tag packet alert structure for tag alerts */
static PacketAlert g_tag_pa;
void PacketAlertTagInit(void)
{
memset(&g_tag_signature, 0x00, sizeof(g_tag_signature));
g_tag_signature.id = TAG_SIG_ID;
g_tag_signature.gid = TAG_SIG_GEN;
g_tag_signature.num = TAG_SIG_ID;
g_tag_signature.rev = 1;
g_tag_signature.prio = 2;
memset(&g_tag_pa, 0x00, sizeof(g_tag_pa));
g_tag_pa.action = ACTION_ALERT;
g_tag_pa.s = &g_tag_signature;
}几种存储结构的初始化与注册
StorageInit();TagInitCtx();ThresholdInit();HostBitInitCtx();IPPairBitInitCtx();这几个函数都在干这种事。
typedef enum StorageEnum_ {
STORAGE_HOST,
STORAGE_FLOW,
STORAGE_IPPAIR,
STORAGE_DEVICE,
STORAGE_MAX,
} StorageEnum;
typedef struct StorageMapping_ {
const char *name;
StorageEnum type; // host, flow, tx, stream, ssn, etc
unsigned int size;
void *(*Alloc)(unsigned int);
void (*Free)(void *);
} StorageMapping;
/** \brief list of StorageMapping used at registration time */
typedef struct StorageList_ {
StorageMapping map;
int id;
struct StorageList_ *next;
} StorageList;
static StorageList *storage_list = NULL;注册所有模块的函数
模块保存到TmModule tmm_modules[TMM_SIZE];实际线程中数据在一连串的模块中依次执行 slot。
typedef struct TmModule_ {
const char *name;
/** thread handling */
TmEcode (*ThreadInit)(ThreadVars *, const void *, void **);
void (*ThreadExitPrintStats)(ThreadVars *, void *);
TmEcode (*ThreadDeinit)(ThreadVars *, void *);
/** the packet processing function */
TmEcode (*Func)(ThreadVars *, Packet *, void *);
TmEcode (*PktAcqLoop)(ThreadVars *, void *, void *);
/** terminates the capture loop in PktAcqLoop */
TmEcode (*PktAcqBreakLoop)(ThreadVars *, void *);
TmEcode (*Management)(ThreadVars *, void *);
/** global Init/DeInit */
TmEcode (*Init)(void);
TmEcode (*DeInit)(void);
#ifdef UNITTESTS
void (*RegisterTests)(void);
#endif
uint8_t cap_flags; /**< Flags to indicate the capability requierment of
the given TmModule */
/* Other flags used by the module */
uint8_t flags;
} TmModule;
TmModule tmm_modules[TMM_SIZE];
void RegisterAllModules(void)
{
// zero all module storage
memset(tmm_modules, 0, TMM_SIZE * sizeof(TmModule));
/* commanders */
TmModuleUnixManagerRegister();
/* managers */
TmModuleFlowManagerRegister();
TmModuleFlowRecyclerRegister();
TmModuleBypassedFlowManagerRegister();
...
/* af-packet */
TmModuleReceiveAFPRegister();
TmModuleDecodeAFPRegister();
...
TmModuleDebugList();
/* nflog */
TmModuleReceiveNFLOGRegister();
TmModuleDecodeNFLOGRegister();
/* windivert */
TmModuleReceiveWinDivertRegister();
TmModuleVerdictWinDivertRegister();
TmModuleDecodeWinDivertRegister();
}
检测引擎初始化：
获取一个检测引擎实例： 初始化检测引擎，设置对应的单模和多模匹配， 根据suricara.yaml 中{detect:}节点设置相应配置， 初始化改引擎实例中保存SigGroupHeads 的哈希表， 初始化改引擎实例中保存MpmStore 的哈希表，初始化改引擎实例中用来剔除重复符号的哈希表，初始化用于存储解析器结果的字符串表示的哈希表等各种哈希表，初始化 IP Reputation，加载classification.config 配置文件中的classification 规则，加载reference.config 配置文件中的reference 规则。加载规则文件的签名规则
static int LoadSignatures(DetectEngineCtx *de_ctx, SCInstance *suri)
{
if (SigLoadSignatures(de_ctx, suri->sig_file, suri->sig_file_exclusive) < 0) {
SCLogError(SC_ERR_NO_RULES_LOADED, "Loading signatures failed.");
if (de_ctx->failure_fatal)
return TM_ECODE_FAILED;
}
return TM_ECODE_OK;
}
实例化的检测引擎 放入全局的 g_master_de_ctx 中
typedef struct DetectEngineMasterCtx_ {
SCMutex lock;
/** enable multi tenant mode */
int multi_tenant_enabled;
/** version, incremented after each 'apply to threads' */
uint32_t version;
/** list of active detection engines. This list is used to generate the
* threads det_ctx's */
DetectEngineCtx *list;
/** free list, containing detection engines that will be removed but may
* still be referenced by det_ctx's. Freed as soon as all references are
* gone. */
DetectEngineCtx *free_list;
enum DetectEngineTenantSelectors tenant_selector;
/** list of tenant mappings. Updated under lock. Used to generate lookup
* structures. */
DetectEngineTenantMapping *tenant_mapping_list;
/** list of keywords that need thread local ctxs,
* only updated by keyword registration at start up. Not
* covered by the lock. */
DetectEngineThreadKeywordCtxItem *keyword_list;
int keyword_id;
} DetectEngineMasterCtx;
static DetectEngineMasterCtx g_master_de_ctx = { SCMUTEX_INITIALIZER,
0, 99, NULL, NULL, TENANT_SELECTOR_UNKNOWN, NULL, NULL, 0};创建工作线程
根据{ 运行模式 + 工作模式 } 获取对应的工作模式RunMode *mode = RunModeGetCustomMode(runmode, custom_mode); 同时mode->RunModeFunc();
执行之前注册数回调函数，例如，这里（RUNMODE_AFP_DEV+ "workers"）这种模式将执行RunModeIdsAFPWorkers() 函数，在RunModeSetLiveCaptureWorkersForDevice函数中，根据配置创建多个worker threads。
static int RunModeSetLiveCaptureWorkersForDevice(ConfigIfaceThreadsCountFunc ModThreadsCount,
const char *recv_mod_name,
const char *decode_mod_name, const char *thread_name,
const char *live_dev, void *aconf,
unsigned char single_mode)
{
...
/* create the threads */
for (int thread = 0; thread < threads_count; thread++) {
...
TmModule *tm_module = NULL;
ThreadVars *tv = TmThreadCreatePacketHandler(tname,
"packetpool", "packetpool",
"packetpool", "packetpool",
"pktacqloop");
if (tv == NULL) {
FatalError(SC_ERR_THREAD_CREATE, "TmThreadsCreate failed");
}
tv->printable_name = printable_threadname;
tm_module = TmModuleGetByName(recv_mod_name);
if (tm_module == NULL) {
FatalError(SC_ERR_INVALID_VALUE, "TmModuleGetByName failed for %s", recv_mod_name);
}
TmSlotSetFuncAppend(tv, tm_module, aconf);
tm_module = TmModuleGetByName(decode_mod_name);
if (tm_module == NULL) {
FatalError(SC_ERR_INVALID_VALUE, "TmModuleGetByName %s failed", decode_mod_name);
}
TmSlotSetFuncAppend(tv, tm_module, NULL);
tm_module = TmModuleGetByName("FlowWorker");
if (tm_module == NULL) {
FatalError(SC_ERR_RUNMODE, "TmModuleGetByName for FlowWorker failed");
}
...
if (TmThreadSpawn(tv) != TM_ECODE_OK) {
FatalError(SC_ERR_THREAD_SPAWN, "TmThreadSpawn failed");
}
}
return 0;
}首先创建在每个工作线程结构 ThreadVars *tv（创建是将线程tv->flags 设置为THV_PAUSE，目的是在后续的子线程创建完成后，在所有的初始完成才运行线程逻辑），在对应的tv 中添加一系列TmSlot。
TmSlot的添加：根据 recv->decode->FlowWorker 相应的模块找到对饮的TmModule，在调用void TmSlotSetFuncAppend(ThreadVars *tv, TmModule *tm, const void *data)函数添加：
void TmSlotSetFuncAppend(ThreadVars *tv, TmModule *tm, const void *data)
{
TmSlot *slot = SCMalloc(sizeof(TmSlot));
if (unlikely(slot == NULL))
return;
memset(slot, 0, sizeof(TmSlot));
SC_ATOMIC_INITPTR(slot->slot_data);
slot->SlotThreadInit = tm->ThreadInit;
slot->slot_initdata = data;
if (tm->Func) {
slot->SlotFunc = tm->Func;
} else if (tm->PktAcqLoop) {
slot->PktAcqLoop = tm->PktAcqLoop;
} else if (tm->Management) {
slot->Management = tm->Management;
}
slot->SlotThreadExitPrintStats = tm->ThreadExitPrintStats;
slot->SlotThreadDeinit = tm->ThreadDeinit;
/* we don't have to check for the return value "-1". We wouldn't have
* received a TM as arg, if it didn't exist */
slot->tm_id = TmModuleGetIDForTM(tm);
tv->tmm_flags |= tm->flags;
tv->cap_flags |= tm->cap_flags;
if (tv->tm_slots == NULL) {
tv->tm_slots = slot;
} else {
TmSlot *a = (TmSlot *)tv->tm_slots, *b = NULL;
/* get the last slot */
for ( ; a != NULL; a = a->slot_next) {
b = a;
}
/* append the new slot */
if (b != NULL) {
b->slot_next = slot;
}
}
return;
}新建一个 TmSlot *slot，将找到的TmModule 中的函数指针赋值给slot对应的函数指针，并把slot节点加入到tv->tm_slots队列中，这一个 slot 与 相应模块的 TmModule *tm是对应的。
在TmEcode TmThreadSpawn(ThreadVars *tv)函数中创建子线程线程（线程函数为tv->tm_func()绑定的回调函数，函数内部绑定cpu，初始化并等待tv->flags 取消THV_PAUSE）， 同时将此线程结构tv 放入ThreadVars *tv_root[TVT_MAX] 中管理，worker threads的类型为TVT_PPT。
TmEcode TmThreadSpawn(ThreadVars *tv)
{
pthread_attr_t attr;
if (tv->tm_func == NULL) {
printf("ERROR: no thread function set\n");
return TM_ECODE_FAILED;
}
/* Initialize and set thread detached attribute */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
int rc = pthread_create(&tv->t, &attr, tv->tm_func, (void *)tv);
if (rc) {
printf("ERROR; return code from pthread_create() is %" PRId32 "\n", rc);
return TM_ECODE_FAILED;
}
TmThreadWaitForFlag(tv, THV_INIT_DONE | THV_RUNNING_DONE);
TmThreadAppend(tv, tv->type);
return TM_ECODE_OK;
}enum {
TVT_PPT,
TVT_MGMT,
TVT_CMD,
TVT_MAX,
};
/* root of the threadvars list */
ThreadVars *tv_root[TVT_MAX] = { NULL };创建非工作线程的子线程
FlowManager线程，FlowRecycler线程， UnixManager线程，wakeup线程， management线程等，创建方法同worker threas的创建。子线程循环函数为tv->tm_func()，在此函数中完成线程的初始化，然后等待线程的 tv->flags 设置为非 THV_PAUSE状态后再执行线程逻辑。
if (runmode != RUNMODE_UNIX_SOCKET) {
/* spawn management threads */
FlowManagerThreadSpawn();
FlowRecyclerThreadSpawn();
if (RunModeNeedsBypassManager()) {
BypassedFlowManagerThreadSpawn();
}
StatsSpawnThreads();
}各子线程函数 tv->tm_func() 对应的回调函数：slot 中的回调函数取自之前注册的 TmModule，各线程的功能见下表：
| 序号 | 线程类型 | name | 线程数量 | tv->type | tv->tm_func()对应的函数 | tv->tm_slots 对应的slot表（TmModule） | 备注 | |
| 1 | worker threads | W | suricata.yaml threading配置 | packetpool | TVT_PPT | TmThreadsSlotPktAcqLoop | Receive ->Decode->FlowWorker | |
| 2 | FlowManagerThread | FM | suricata.yaml flow.managers | management | TVT_MGMT | TmThreadsManagement | FlowManager | 默认为1个 |
| 3 | FlowRecyclerThread | FR | suricata.yaml flow.recyclers | management | TVT_MGMT | TmThreadsManagement | FlowRecycler | 默认为1个 |
| 4 | BypassedFlowManagerThread | FB | 1 | management | TVT_MGMT | TmThreadsManagement | BypassedFlowManager | |
| 5 | StatsWakeupThread | CW | 1 | custom | TVT_MGMT | StatsWakeupThread | 无 | |
| 6 | StatsMgmtThread | CS | 1 | custom | TVT_MGMT | StatsMgmtThread | 无 | |
| 7 | UnixManagerThread | US | 2 or 0 | command | TVT_CMD | TmThreadsManagement | UnixManager | RUNMODE_UNIX_SOCKET mode是才创建，否则没有 |
| 8 | DetectLoaderThread | DL | suricata.yaml multi-detect.loaders or 0 | command | TVT_CMD | TmThreadsManagement | DetectLoader | MT(多租户)被启用才创建，默认的配置没有此项。 |
所有子线程创建完成后，等待所有子线程初始化完成，设置max_pending_return_packets值 ,取消所有线程的暂停标志，这样所有线程都能愉快的玩耍了。
主线程进入主循环：
主循环中处理SIGTERM（kill 不加参数）、SIGINT（ctrl + c）信号，当有这两个信号中的其中之一时，退出主循环，此时程序优雅的退出；
检测 上面的各个子线程的状态，若有线程为 THV_FAILED状态（线程遇到错误并失败），这是退出程序，exit(0)，不优雅；
处理SIGHUP 信号
处理SIGUSR2 信号，以用来动态加载规则，发送信号方式 { kill -USR2 $(pidof suricata) }；
主循环退出后，关闭所有子线程，释放所有的资源，程序优雅的退出，至此，主线程完结！
凡是过往，即为序章
866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
