41 #if (defined BUILD_UNIX_SOCKET) && (defined HAVE_SYS_UN_H) && (defined HAVE_SYS_STAT_H) && (defined HAVE_SYS_TYPES_H) 44 #include <sys/types.h> 52 # define MSG_NOSIGNAL SO_NOSIGPIPE 56 #define SOCKET_PATH LOCAL_STATE_DIR "/run/suricata/" 57 #define SOCKET_FILENAME "suricata-command.socket" 58 #define SOCKET_TARGET SOCKET_PATH SOCKET_FILENAME 60 #define MAX_FAILED_RULES 20 62 typedef struct Command_ {
64 TmEcode (*Func)(json_t *, json_t *,
void *);
70 typedef struct Task_ {
76 #define CLIENT_BUFFER_SIZE 4096 77 typedef struct UnixClient_ {
84 typedef struct UnixCommand_ {
85 time_t start_timestamp;
87 struct sockaddr_un client_addr;
99 static
int UnixNew(UnixCommand * this)
101 struct sockaddr_un addr;
105 char sockettarget[PATH_MAX];
106 const char *socketname;
108 this->start_timestamp = time(NULL);
110 this->select_max = 0;
117 if (
ConfGet(
"unix-command.filename", &socketname) == 1) {
119 strlcpy(sockettarget, socketname,
sizeof(sockettarget));
121 snprintf(sockettarget,
sizeof(sockettarget),
"%s/%s",
122 SOCKET_PATH, socketname);
126 strlcpy(sockettarget, SOCKET_TARGET,
sizeof(sockettarget));
129 SCLogInfo(
"Using unix socket file '%s'", sockettarget);
132 struct stat stat_buf;
134 if (stat(SOCKET_PATH, &stat_buf) != 0) {
136 ret =
SCMkDir(SOCKET_PATH, S_IRWXU|S_IXGRP|S_IRGRP);
141 "Cannot create socket directory %s: %s",
142 SOCKET_PATH, strerror(err));
153 (void) unlink(sockettarget);
156 addr.sun_family = AF_UNIX;
157 strlcpy(addr.sun_path, sockettarget,
sizeof(addr.sun_path));
158 addr.sun_path[
sizeof(addr.sun_path) - 1] = 0;
159 len = strlen(addr.sun_path) +
sizeof(addr.sun_family) + 1;
162 this->socket = socket(AF_UNIX, SOCK_STREAM, 0);
163 if (this->socket == -1) {
165 "Unix Socket: unable to create UNIX socket %s: %s",
166 addr.sun_path, strerror(errno));
169 this->select_max = this->socket + 1;
172 ret = setsockopt(this->socket, SOL_SOCKET, SO_REUSEADDR,
173 (
char *) &on,
sizeof(on));
176 "Cannot set sockets options: %s.", strerror(errno));
180 ret = bind(this->socket, (
struct sockaddr *) &addr, len);
183 "Unix socket: UNIX socket bind(%s) error: %s",
184 sockettarget, strerror(errno));
188 #if !(defined OS_FREEBSD || defined __OpenBSD__) 192 ret = chmod(sockettarget, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
196 "Unable to change permission on socket: %s (%d)",
203 if (listen(this->socket, 1) == -1) {
205 "Command server: UNIX socket listen() error: %s",
212 static void UnixCommandSetMaxFD(UnixCommand *
this)
221 this->select_max = this->socket + 1;
223 if (item->fd >= this->select_max) {
224 this->select_max = item->fd + 1;
229 static UnixClient *UnixClientAlloc(
void)
231 UnixClient *uclient =
SCMalloc(
sizeof(UnixClient));
237 if (uclient->mbuf == NULL) {
245 static void UnixClientFree(UnixClient *c)
256 static void UnixCommandClose(UnixCommand *
this,
int fd)
262 if (item->fd == fd) {
276 UnixCommandSetMaxFD(
this);
277 UnixClientFree(item);
280 #define UNIX_PROTO_VERSION_LENGTH 200 281 #define UNIX_PROTO_VERSION_V1 "0.1" 282 #define UNIX_PROTO_V1 1 283 #define UNIX_PROTO_VERSION "0.2" 284 #define UNIX_PROTO_V2 2 286 static int UnixCommandSendJSONToClient(UnixClient *client, json_t *js)
292 .expand_by = CLIENT_BUFFER_SIZE
296 JSON_PRESERVE_ORDER|JSON_COMPACT|JSON_ENSURE_ASCII|
303 if (client->version > UNIX_PROTO_V1) {
319 SCLogDebug(
"sent message of size %"PRIuMAX
" to client socket %d",
333 static int UnixCommandAccept(UnixCommand *
this)
335 char buffer[UNIX_PROTO_VERSION_LENGTH + 1];
343 UnixClient *uclient = NULL;
346 socklen_t len =
sizeof(this->client_addr);
347 client = accept(this->socket, (
struct sockaddr *) &this->client_addr,
350 SCLogInfo(
"Unix socket: accept() error: %s",
357 buffer[
sizeof(buffer)-1] = 0;
358 ret = recv(client, buffer,
sizeof(buffer)-1, 0);
360 SCLogInfo(
"Command server: client doesn't send version");
364 if (ret >= (
int)(
sizeof(buffer)-1)) {
365 SCLogInfo(
"Command server: client message is too long, " 372 client_msg = json_loads(buffer, 0, &jerror);
373 if (client_msg == NULL) {
374 SCLogInfo(
"Invalid command, error on line %d: %s\n", jerror.line, jerror.text);
379 version = json_object_get(client_msg,
"version");
380 if (!json_is_string(version)) {
381 SCLogInfo(
"error: version is not a string");
383 json_decref(client_msg);
388 if ((strcmp(json_string_value(version), UNIX_PROTO_VERSION) != 0)
389 && (strcmp(json_string_value(version), UNIX_PROTO_VERSION_V1) != 0)) {
390 SCLogInfo(
"Unix socket: invalid client version: \"%s\"",
391 json_string_value(version));
392 json_decref(client_msg);
396 SCLogDebug(
"Unix socket: client version: \"%s\"",
397 json_string_value(version));
398 if (strcmp(json_string_value(version), UNIX_PROTO_VERSION_V1) == 0) {
399 client_version = UNIX_PROTO_V1;
401 client_version = UNIX_PROTO_V2;
405 json_decref(client_msg);
407 server_msg = json_object();
408 if (server_msg == NULL) {
412 json_object_set_new(server_msg,
"return", json_string(
"OK"));
414 uclient = UnixClientAlloc();
417 json_decref(server_msg);
421 uclient->fd = client;
422 uclient->version = client_version;
424 if (UnixCommandSendJSONToClient(uclient, server_msg) != 0) {
427 UnixClientFree(uclient);
428 json_decref(server_msg);
433 json_decref(server_msg);
438 UnixCommandSetMaxFD(
this);
442 static int UnixCommandBackgroundTasks(UnixCommand*
this)
448 int fret = ltask->Func(ltask->data);
465 static int UnixCommandExecute(UnixCommand *
this,
char *command, UnixClient *client)
469 json_t *jsoncmd = NULL;
471 json_t *server_msg = json_object();
476 if (server_msg == NULL) {
480 jsoncmd = json_loads(command, 0, &error);
481 if (jsoncmd == NULL) {
482 SCLogInfo(
"Invalid command, error on line %d: %s\n", error.line, error.text);
486 cmd = json_object_get(jsoncmd,
"command");
487 if(!json_is_string(cmd)) {
488 SCLogInfo(
"error: command is not a string");
491 value = json_string_value(cmd);
494 if (!strcmp(value, lcmd->name)) {
498 cmd = json_object_get(jsoncmd,
"arguments");
499 if(!json_is_object(cmd)) {
500 SCLogInfo(
"error: argument is not an object");
504 fret = lcmd->Func(cmd, server_msg, lcmd->data);
513 json_object_set_new(server_msg,
"message", json_string(
"Unknown command"));
519 json_object_set_new(server_msg,
"return", json_string(
"NOK"));
522 json_object_set_new(server_msg,
"return", json_string(
"OK"));
526 if (UnixCommandSendJSONToClient(client, server_msg) != 0) {
530 json_decref(jsoncmd);
531 json_decref(server_msg);
535 json_decref(jsoncmd);
537 json_decref(server_msg);
538 UnixCommandClose(
this, client->fd);
542 static void UnixCommandRun(UnixCommand *
this, UnixClient *client)
546 if (client->version <= UNIX_PROTO_V1) {
547 ret = recv(client->fd, buffer,
sizeof(buffer) - 1, 0);
550 SCLogDebug(
"Unix socket: lost connection with client");
555 UnixCommandClose(
this, client->fd);
558 if (ret >= (
int)(
sizeof(buffer)-1)) {
561 UnixCommandClose(
this, client->fd);
568 ret = recv(client->fd, buffer + offset,
sizeof(buffer) - offset - 1, 0);
572 SCLogInfo(
"Unix socket: lost connection with client");
574 SCLogInfo(
"Unix socket: error on recv() from client: %s",
577 UnixCommandClose(
this, client->fd);
580 if (ret >= (
int)(
sizeof(buffer)- offset - 1)) {
581 SCLogInfo(
"Command server: client command is too long, " 583 UnixCommandClose(
this, client->fd);
585 if (buffer[ret - 1] ==
'\n') {
593 FD_ZERO(&select_set);
594 FD_SET(client->fd, &select_set);
596 tv.tv_usec = 200 * 1000;
598 ret = select(client->fd, &select_set, NULL, NULL, &tv);
602 if (errno != EINTR) {
603 SCLogInfo(
"Unix socket: lost connection with client");
604 UnixCommandClose(
this, client->fd);
608 }
while (ret == 0 &&
try < 3);
610 ret = recv(client->fd, buffer + offset,
611 sizeof(buffer) - offset - 1, 0);
614 }
while (
try < 3 && cmd_over == 0);
616 if (
try == 3 && cmd_over == 0) {
617 SCLogInfo(
"Unix socket: imcomplete client message, closing connection");
618 UnixCommandClose(
this, client->fd);
622 UnixCommandExecute(
this, buffer, client);
630 static int UnixMain(UnixCommand *
this)
639 FD_ZERO(&select_set);
640 FD_SET(this->socket, &select_set);
642 FD_SET(uclient->fd, &select_set);
646 tv.tv_usec = 200 * 1000;
647 ret = select(this->select_max, &select_set, NULL, NULL, &tv);
652 if (errno == EINTR) {
661 UnixCommandClose(
this, uclient->fd);
672 if (FD_ISSET(uclient->fd, &select_set)) {
673 UnixCommandRun(
this, uclient);
676 if (FD_ISSET(this->socket, &select_set)) {
677 if (!UnixCommandAccept(
this))
684 static TmEcode UnixManagerShutdownCommand(json_t *cmd,
685 json_t *server_msg,
void *data)
688 json_object_set_new(server_msg,
"message", json_string(
"Closing Suricata"));
693 static TmEcode UnixManagerVersionCommand(json_t *cmd,
694 json_t *server_msg,
void *data)
701 static TmEcode UnixManagerUptimeCommand(json_t *cmd,
702 json_t *server_msg,
void *data)
706 UnixCommand *ucmd = (UnixCommand *)data;
708 uptime = time(NULL) - ucmd->start_timestamp;
709 json_object_set_new(server_msg,
"message", json_integer(uptime));
713 static TmEcode UnixManagerRunningModeCommand(json_t *cmd,
714 json_t *server_msg,
void *data)
717 json_object_set_new(server_msg,
"message", json_string(
RunmodeGetActive()));
721 static TmEcode UnixManagerCaptureModeCommand(json_t *cmd,
722 json_t *server_msg,
void *data)
729 static TmEcode UnixManagerReloadRulesWrapper(json_t *cmd, json_t *server_msg,
void *data,
int do_wait)
734 json_object_set_new(server_msg,
"message",
735 json_string(
"Live rule reload not possible if -s " 736 "or -S option used at runtime."));
742 if (r == 0 && do_wait) {
747 json_object_set_new(server_msg,
"message", json_string(
"Reload already in progress"));
752 json_object_set_new(server_msg,
"message", json_string(
"done"));
756 static TmEcode UnixManagerReloadRules(json_t *cmd, json_t *server_msg,
void *data)
758 return UnixManagerReloadRulesWrapper(cmd, server_msg, data, 1);
761 static TmEcode UnixManagerNonBlockingReloadRules(json_t *cmd, json_t *server_msg,
void *data)
763 return UnixManagerReloadRulesWrapper(cmd, server_msg, data, 0);
766 static TmEcode UnixManagerReloadTimeCommand(json_t *cmd,
767 json_t *server_msg,
void *data)
771 json_t *jdata = NULL;
774 json_object_set_new(server_msg,
"message", jdata);
778 static TmEcode UnixManagerRulesetStatsCommand(json_t *cmd,
779 json_t *server_msg,
void *data)
783 json_t *jdata = NULL;
786 json_object_set_new(server_msg,
"message", jdata);
790 static TmEcode UnixManagerShowFailedRules(json_t *cmd,
791 json_t *server_msg,
void *data)
796 if (de_ctx == NULL) {
797 json_object_set_new(server_msg,
"message", json_string(
"Unable to get info"));
803 json_t *js_sigs_array = json_array();
805 if (js_sigs_array == NULL) {
806 json_object_set_new(server_msg,
"message", json_string(
"Unable to get info"));
812 json_t *jdata = json_object();
814 json_object_set_new(server_msg,
"message", json_string(
"Unable to get the sig"));
818 json_object_set_new(jdata,
"tenant_id", json_integer(list->
tenant_id));
819 json_object_set_new(jdata,
"rule", json_string(sigs_str->
sig_str));
820 json_object_set_new(jdata,
"filename", json_string(sigs_str->
filename));
821 json_object_set_new(jdata,
"line", json_integer(sigs_str->
line));
823 json_object_set_new(jdata,
"error", json_string(sigs_str->
sig_error));
825 json_array_append_new(js_sigs_array, jdata);
826 if (++rules_cnt > MAX_FAILED_RULES) {
830 if (rules_cnt > MAX_FAILED_RULES) {
836 json_object_set_new(server_msg,
"message", js_sigs_array);
842 json_object_clear(js_sigs_array);
843 json_decref(js_sigs_array);
847 static TmEcode UnixManagerConfGetCommand(json_t *cmd,
848 json_t *server_msg,
void *data)
852 const char *confval = NULL;
853 char *variable = NULL;
855 json_t *jarg = json_object_get(cmd,
"variable");
856 if(!json_is_string(jarg)) {
857 SCLogInfo(
"error: variable is not a string");
858 json_object_set_new(server_msg,
"message", json_string(
"variable is not a string"));
862 variable = (
char *)json_string_value(jarg);
863 if (
ConfGet(variable, &confval) != 1) {
864 json_object_set_new(server_msg,
"message", json_string(
"Unable to get value"));
869 json_object_set_new(server_msg,
"message", json_string(confval));
873 json_object_set_new(server_msg,
"message", json_string(
"No string value"));
877 static TmEcode UnixManagerListCommand(json_t *cmd,
878 json_t *answer,
void *data)
883 Command *lcmd = NULL;
884 UnixCommand *gcmd = (UnixCommand *) data;
887 jdata = json_object();
889 json_object_set_new(answer,
"message",
890 json_string(
"internal error at json object creation"));
893 jarray = json_array();
894 if (jarray == NULL) {
895 json_object_set_new(answer,
"message",
896 json_string(
"internal error at json object creation"));
901 json_array_append_new(jarray, json_string(lcmd->name));
905 json_object_set_new(jdata,
"count", json_integer(i));
906 json_object_set_new(jdata,
"commands", jarray);
907 json_object_set_new(answer,
"message", jdata);
911 static TmEcode UnixManagerReopenLogFiles(json_t *cmd, json_t *server_msg,
void *data)
914 json_object_set_new(server_msg,
"message", json_string(
"done"));
919 TmEcode UnixManagerReloadRules(json_t *cmd,
920 json_t *server_msg,
void *data)
924 json_object_set_new(server_msg,
"message",
925 json_string(
"Live rule swap no longer possible." 926 " Engine in shutdown mode."));
931 DetectEngineSpawnLiveRuleSwapMgmtThread();
932 json_object_set_new(server_msg,
"message", json_string(
"Reloading rules"));
938 static UnixCommand command;
956 TmEcode UnixManagerRegisterCommand(
const char * keyword,
957 TmEcode (*Func)(json_t *, json_t *,
void *),
958 void *data,
int flags)
962 Command *lcmd = NULL;
969 if (keyword == NULL) {
975 if (!strcmp(keyword, lcmd->name)) {
1011 TmEcode UnixManagerRegisterBackgroundTask(
TmEcode (*Func)(
void *),
1037 if (UnixNew(&command) == 0) {
1038 int failure_fatal = 0;
1039 if (
ConfGetBool(
"engine.init-failure-fatal", &failure_fatal) != 1) {
1040 SCLogDebug(
"ConfGetBool could not load the value.");
1042 if (failure_fatal) {
1044 "Unable to create unix command socket");
1048 "Unable to create unix command socket");
1054 UnixManagerRegisterCommand(
"shutdown", UnixManagerShutdownCommand, NULL, 0);
1055 UnixManagerRegisterCommand(
"command-list", UnixManagerListCommand, &command, 0);
1056 UnixManagerRegisterCommand(
"help", UnixManagerListCommand, &command, 0);
1057 UnixManagerRegisterCommand(
"version", UnixManagerVersionCommand, &command, 0);
1058 UnixManagerRegisterCommand(
"uptime", UnixManagerUptimeCommand, &command, 0);
1059 UnixManagerRegisterCommand(
"running-mode", UnixManagerRunningModeCommand, &command, 0);
1060 UnixManagerRegisterCommand(
"capture-mode", UnixManagerCaptureModeCommand, &command, 0);
1061 UnixManagerRegisterCommand(
"conf-get", UnixManagerConfGetCommand, &command,
UNIX_CMD_TAKE_ARGS);
1062 UnixManagerRegisterCommand(
"dump-counters", StatsOutputCounterSocket, NULL, 0);
1063 UnixManagerRegisterCommand(
"reload-rules", UnixManagerReloadRules, NULL, 0);
1064 UnixManagerRegisterCommand(
"ruleset-reload-rules", UnixManagerReloadRules, NULL, 0);
1065 UnixManagerRegisterCommand(
"ruleset-reload-nonblocking", UnixManagerNonBlockingReloadRules, NULL, 0);
1066 UnixManagerRegisterCommand(
"ruleset-reload-time", UnixManagerReloadTimeCommand, NULL, 0);
1067 UnixManagerRegisterCommand(
"ruleset-stats", UnixManagerRulesetStatsCommand, NULL, 0);
1068 UnixManagerRegisterCommand(
"ruleset-failed-rules", UnixManagerShowFailedRules, NULL, 0);
1069 UnixManagerRegisterCommand(
"register-tenant-handler", UnixSocketRegisterTenantHandler, &command,
UNIX_CMD_TAKE_ARGS);
1070 UnixManagerRegisterCommand(
"unregister-tenant-handler", UnixSocketUnregisterTenantHandler, &command,
UNIX_CMD_TAKE_ARGS);
1071 UnixManagerRegisterCommand(
"register-tenant", UnixSocketRegisterTenant, &command,
UNIX_CMD_TAKE_ARGS);
1072 UnixManagerRegisterCommand(
"reload-tenant", UnixSocketReloadTenant, &command,
UNIX_CMD_TAKE_ARGS);
1073 UnixManagerRegisterCommand(
"unregister-tenant", UnixSocketUnregisterTenant, &command,
UNIX_CMD_TAKE_ARGS);
1074 UnixManagerRegisterCommand(
"add-hostbit", UnixSocketHostbitAdd, &command,
UNIX_CMD_TAKE_ARGS);
1075 UnixManagerRegisterCommand(
"remove-hostbit", UnixSocketHostbitRemove, &command,
UNIX_CMD_TAKE_ARGS);
1076 UnixManagerRegisterCommand(
"list-hostbit", UnixSocketHostbitList, &command,
UNIX_CMD_TAKE_ARGS);
1077 UnixManagerRegisterCommand(
"reopen-log-files", UnixManagerReopenLogFiles, NULL, 0);
1078 UnixManagerRegisterCommand(
"memcap-set", UnixSocketSetMemcap, &command,
UNIX_CMD_TAKE_ARGS);
1079 UnixManagerRegisterCommand(
"memcap-show", UnixSocketShowMemcap, &command,
UNIX_CMD_TAKE_ARGS);
1080 UnixManagerRegisterCommand(
"memcap-list", UnixSocketShowAllMemcap, NULL, 0);
1082 UnixManagerRegisterCommand(
"dataset-add", UnixSocketDatasetAdd, &command,
UNIX_CMD_TAKE_ARGS);
1087 typedef struct UnixManagerThreadData_ {
1089 } UnixManagerThreadData;
1091 static TmEcode UnixManagerThreadInit(
ThreadVars *t,
const void *initdata,
void **data)
1093 UnixManagerThreadData *utd =
SCCalloc(1,
sizeof(*utd));
1122 ret = UnixMain(&command);
1138 UnixCommandBackgroundTasks(&command);
1158 if (tv_unixmgr == NULL) {
1180 if (unix_socket == 1) {
1182 UnixManagerRegisterCommand(
"iface-stat", LiveDeviceIfaceStat, NULL,
1184 UnixManagerRegisterCommand(
"iface-list", LiveDeviceIfaceList, NULL, 0);
1185 UnixManagerRegisterCommand(
"iface-bypassed-stat",
1186 LiveDeviceGetBypassedStats, NULL, 0);
1188 UnixManagerRegisterCommand(
"ebpf-bypassed-stat",
1189 LiveDeviceGetBypassedStats, NULL, 0);
1211 while (tv != NULL) {
1212 if (strcasecmp(tv->
name,
"UnixManagerThread") == 0) {
1261 #if defined(BUILD_UNIX_SOCKET) && defined(HAVE_SYS_UN_H) && defined(HAVE_SYS_STAT_H) && defined(HAVE_SYS_TYPES_H)
MemBuffer * MemBufferCreateNew(uint32_t size)
#define MemBufferWriteRaw(dst, raw_buffer, raw_buffer_len)
Write a raw buffer to the MemBuffer dst.
#define MEMBUFFER_SIZE(mem_buffer)
Get the MemBuffers current size.
#define TAILQ_FOREACH(var, head, field)
struct HtpBodyChunk_ * next
size_t strlcpy(char *dst, const char *src, size_t siz)
void DetectEngineDeReference(DetectEngineCtx **de_ctx)
DetectEngineCtx * DetectEngineGetCurrent(void)
int ConfGetBool(const char *name, int *val)
Retrieve a configuration value as an boolen.
#define MemBufferReset(mem_buffer)
Reset the mem buffer.
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
int ConfUnixSocketIsEnable(void)
volatile uint8_t suricata_ctl_flags
#define TAILQ_HEAD(name, type)
ThreadVars * TmThreadCreateCmdThreadByName(const char *name, const char *module, int mucond)
Creates and returns the TV instance for a Command thread (CMD). This function supports only custom sl...
int ConfGet(const char *name, const char **vptr)
Retrieve the value of a configuration node.
char * RunmodeGetActive(void)
main detection engine ctx
int UnixManagerInit(void)
const char * GetProgramVersion(void)
get string with program version
void TmThreadsSetFlag(ThreadVars *tv, uint16_t flag)
Set a thread flag.
SCCtrlMutex unix_manager_ctrl_mutex
#define UNIX_CMD_TAKE_ARGS
#define SCMutexUnlock(mut)
TmEcode(* Management)(ThreadVars *, void *)
#define SCLogError(err_code,...)
Macro used to log ERROR messages.
struct ThreadVars_ * next
struct DetectEngineCtx_ * next
#define TAILQ_REMOVE(head, elm, field)
TmEcode(* ThreadDeinit)(ThreadVars *, void *)
SigFileLoaderStat sig_stat
int DetectEngineReloadIsIdle(void)
SCCtrlCondT unix_manager_ctrl_cond
void UnixManagerThreadSpawn(int mode)
int PathIsAbsolute(const char *path)
Check if a path is absolute.
#define SCLogWarning(err_code,...)
Macro used to log WARNING messages.
void UnixSocketKillSocketThread(void)
TmEcode OutputEngineStatsRuleset(json_t **jdata)
#define MEMBUFFER_BUFFER(mem_buffer)
Get the MemBuffers underlying buffer.
#define TAILQ_INSERT_TAIL(head, elm, field)
int OutputJSONMemBufferCallback(const char *str, size_t size, void *data)
void TmModuleUnixManagerRegister(void)
#define JSON_ESCAPE_SLASH
#define SCLogInfo(...)
Macro used to log INFORMATIONAL messages.
TmModule tmm_modules[TMM_SIZE]
#define TAILQ_ENTRY(type)
const char * RunModeGetMainMode(void)
#define MEMBUFFER_OFFSET(mem_buffer)
Get the MemBuffers current offset.
TmEcode OutputEngineStatsReloadTime(json_t **jdata)
TmEcode(* ThreadInit)(ThreadVars *, const void *, void **)
int StatsSetupPrivate(ThreadVars *tv)
int TmThreadsCheckFlag(ThreadVars *tv, uint16_t flag)
Check if a thread flag is set.
#define StatsSyncCounters(tv)
int DetectEngineReloadStart(void)
void EngineStop(void)
make sure threads can stop the engine by calling this function. Purpose: pcap file mode needs to be a...
ThreadVars * tv_root[TVT_MAX]
void UtilSignalHandlerSetup(int sig, void(*handler)(int))
Per thread variable structure.
#define SCCtrlMutexInit(mut, mutattr)
const char * thread_name_unix_socket
void UnixManagerThreadSpawnNonRunmode(void)
int MemBufferExpand(MemBuffer **buffer, uint32_t expand_by)
expand membuffer by size of 'expand_by'
TmEcode TmThreadSpawn(ThreadVars *tv)
Spawns a thread associated with the ThreadVars instance tv.
void MemBufferFree(MemBuffer *buffer)
#define TM_FLAG_COMMAND_TM
void OutputNotifyFileRotation(void)
Notifies all registered file rotation notification flags.