aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Consistency fix.. Xxxlog -> XxxLog.

Browse Source
remotes/origin/master-1.0.x
Jason Ish 17 years ago committed by Victor Julien
parent e204d07717
commit 095f2cf6ef
10 changed files with 171 additions and 162 deletions
Show Stats Download Patch File Download Diff File

76
src/alert-debuglog.c
Unescape Escape View File

@ -31,30 +31,32 @@
#define DEFAULT_LOG_FILENAME "alert-debug.log"
TmEcode AlertDebuglog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertDebuglogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertDebuglogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertDebuglogThreadInit(ThreadVars *, void*, void **);
TmEcode AlertDebuglogThreadDeinit(ThreadVars *, void *);
void AlertDebuglogExitPrintStats(ThreadVars *, void *);
int AlertDebuglogOpenFileCtx(LogFileCtx* , const char *);
void TmModuleAlertDebuglogRegister (void) {
tmm_modules[TMM_ALERTDEBUGLOG].name = "AlertDebuglog";
tmm_modules[TMM_ALERTDEBUGLOG].ThreadInit = AlertDebuglogThreadInit;
tmm_modules[TMM_ALERTDEBUGLOG].Func = AlertDebuglog;
tmm_modules[TMM_ALERTDEBUGLOG].ThreadExitPrintStats = AlertDebuglogExitPrintStats;
tmm_modules[TMM_ALERTDEBUGLOG].ThreadDeinit = AlertDebuglogThreadDeinit;
#define MODULE_NAME "AlertDebugLog"
TmEcode AlertDebugLog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertDebugLogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertDebugLogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertDebugLogThreadInit(ThreadVars *, void*, void **);
TmEcode AlertDebugLogThreadDeinit(ThreadVars *, void *);
void AlertDebugLogExitPrintStats(ThreadVars *, void *);
int AlertDebugLogOpenFileCtx(LogFileCtx* , const char *);
void TmModuleAlertDebugLogRegister (void) {
tmm_modules[TMM_ALERTDEBUGLOG].name = MODULE_NAME;
tmm_modules[TMM_ALERTDEBUGLOG].ThreadInit = AlertDebugLogThreadInit;
tmm_modules[TMM_ALERTDEBUGLOG].Func = AlertDebugLog;
tmm_modules[TMM_ALERTDEBUGLOG].ThreadExitPrintStats = AlertDebugLogExitPrintStats;
tmm_modules[TMM_ALERTDEBUGLOG].ThreadDeinit = AlertDebugLogThreadDeinit;
tmm_modules[TMM_ALERTDEBUGLOG].RegisterTests = NULL;
OutputRegisterModule("AlertDebuglog", "alert-debug", AlertDebuglogInitCtx);
OutputRegisterModule(MODULE_NAME, "alert-debug", AlertDebugLogInitCtx);
}
typedef struct AlertDebuglogThread_ {
typedef struct AlertDebugLogThread_ {
LogFileCtx *file_ctx;
/** LogFileCtx has the pointer to the file and a mutex to allow multithreading */
uint32_t alerts;
} AlertDebuglogThread;
} AlertDebugLogThread;
static void CreateTimeString (const struct timeval *ts, char *str, size_t size) {
time_t time = ts->tv_sec;
@ -67,9 +69,9 @@ static void CreateTimeString (const struct timeval *ts, char *str, size_t size)
(uint32_t) ts->tv_usec);
}
TmEcode AlertDebuglogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode AlertDebugLogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
AlertDebugLogThread *aft = (AlertDebugLogThread *)data;
int i;
char timebuf[64];
@ -148,9 +150,9 @@ TmEcode AlertDebuglogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq
return TM_ECODE_OK;
}
TmEcode AlertDebuglogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode AlertDebugLogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
AlertDebugLogThread *aft = (AlertDebugLogThread *)data;
int i;
char timebuf[64];
@ -178,24 +180,24 @@ TmEcode AlertDebuglogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq
return TM_ECODE_OK;
}
TmEcode AlertDebuglog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode AlertDebugLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
if (PKT_IS_IPV4(p)) {
return AlertDebuglogIPv4(tv, p, data, pq);
return AlertDebugLogIPv4(tv, p, data, pq);
} else if (PKT_IS_IPV6(p)) {
return AlertDebuglogIPv6(tv, p, data, pq);
return AlertDebugLogIPv6(tv, p, data, pq);
}
return TM_ECODE_OK;
}
TmEcode AlertDebuglogThreadInit(ThreadVars *t, void *initdata, void **data)
TmEcode AlertDebugLogThreadInit(ThreadVars *t, void *initdata, void **data)
{
AlertDebuglogThread *aft = malloc(sizeof(AlertDebuglogThread));
AlertDebugLogThread *aft = malloc(sizeof(AlertDebugLogThread));
if (aft == NULL) {
return TM_ECODE_FAILED;
}
memset(aft, 0, sizeof(AlertDebuglogThread));
memset(aft, 0, sizeof(AlertDebugLogThread));
if(initdata == NULL)
{
@ -209,22 +211,22 @@ TmEcode AlertDebuglogThreadInit(ThreadVars *t, void *initdata, void **data)
return TM_ECODE_OK;
}
TmEcode AlertDebuglogThreadDeinit(ThreadVars *t, void *data)
TmEcode AlertDebugLogThreadDeinit(ThreadVars *t, void *data)
{
AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
AlertDebugLogThread *aft = (AlertDebugLogThread *)data;
if (aft == NULL) {
return TM_ECODE_OK;
}
/* clear memory */
memset(aft, 0, sizeof(AlertDebuglogThread));
memset(aft, 0, sizeof(AlertDebugLogThread));
free(aft);
return TM_ECODE_OK;
}
void AlertDebuglogExitPrintStats(ThreadVars *tv, void *data) {
AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
void AlertDebugLogExitPrintStats(ThreadVars *tv, void *data) {
AlertDebugLogThread *aft = (AlertDebugLogThread *)data;
if (aft == NULL) {
return;
}
@ -237,14 +239,14 @@ void AlertDebuglogExitPrintStats(ThreadVars *tv, void *data) {
* \param ConfNode containing configuration for this logger.
* \return NULL if failure, LogFileCtx* to the file_ctx if succesful
* */
LogFileCtx *AlertDebuglogInitCtx(ConfNode *conf)
LogFileCtx *AlertDebugLogInitCtx(ConfNode *conf)
{
int ret=0;
LogFileCtx* file_ctx=LogFileNewCtx();
if(file_ctx == NULL)
{
SCLogDebug("AlertDebuglogInitCtx: Couldn't create new file_ctx");
SCLogDebug("AlertDebugLogInitCtx: Couldn't create new file_ctx");
return NULL;
}
@ -252,8 +254,8 @@ LogFileCtx *AlertDebuglogInitCtx(ConfNode *conf)
if (filename == NULL)
filename = DEFAULT_LOG_FILENAME;
/** fill the new LogFileCtx with the specific AlertDebuglog configuration */
ret=AlertDebuglogOpenFileCtx(file_ctx, filename);
/** fill the new LogFileCtx with the specific AlertDebugLog configuration */
ret=AlertDebugLogOpenFileCtx(file_ctx, filename);
if(ret < 0)
return NULL;
@ -266,7 +268,7 @@ LogFileCtx *AlertDebuglogInitCtx(ConfNode *conf)
* \param filename name of log file
* \return -1 if failure, 0 if succesful
* */
int AlertDebuglogOpenFileCtx(LogFileCtx *file_ctx, const char *filename)
int AlertDebugLogOpenFileCtx(LogFileCtx *file_ctx, const char *filename)
{
int ret=0;

8
src/alert-debuglog.h
Unescape Escape View File

@ -3,10 +3,10 @@
#ifndef __ALERT_DEBUGLOG_H__
#define __ALERT_DEBUGLOG_H__
void TmModuleAlertDebuglogRegister (void);
void TmModuleAlertDebuglogIPv4Register (void);
void TmModuleAlertDebuglogIPv6Register (void);
LogFileCtx *AlertDebuglogInitCtx(ConfNode *);
void TmModuleAlertDebugLogRegister (void);
void TmModuleAlertDebugLogIPv4Register (void);
void TmModuleAlertDebugLogIPv6Register (void);
LogFileCtx *AlertDebugLogInitCtx(ConfNode *);
#endif /* __ALERT_DEBUGLOG_H__ */

98
src/alert-fastlog.c
Unescape Escape View File

@ -35,49 +35,51 @@
#define DEFAULT_LOG_FILENAME "fast.log"
TmEcode AlertFastlog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertFastlogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertFastlogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertFastlogThreadInit(ThreadVars *, void *, void **);
TmEcode AlertFastlogThreadDeinit(ThreadVars *, void *);
void AlertFastlogExitPrintStats(ThreadVars *, void *);
int AlertFastlogOpenFileCtx(LogFileCtx *, const char *);
#define MODULE_NAME "AlertFastLog"
TmEcode AlertFastLog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertFastLogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertFastLogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertFastLogThreadInit(ThreadVars *, void *, void **);
TmEcode AlertFastLogThreadDeinit(ThreadVars *, void *);
void AlertFastLogExitPrintStats(ThreadVars *, void *);
int AlertFastLogOpenFileCtx(LogFileCtx *, const char *);
void AlertFastLogRegisterTests(void);
void TmModuleAlertFastlogRegister (void) {
tmm_modules[TMM_ALERTFASTLOG].name = "AlertFastlog";
tmm_modules[TMM_ALERTFASTLOG].ThreadInit = AlertFastlogThreadInit;
tmm_modules[TMM_ALERTFASTLOG].Func = AlertFastlog;
tmm_modules[TMM_ALERTFASTLOG].ThreadExitPrintStats = AlertFastlogExitPrintStats;
tmm_modules[TMM_ALERTFASTLOG].ThreadDeinit = AlertFastlogThreadDeinit;
void TmModuleAlertFastLogRegister (void) {
tmm_modules[TMM_ALERTFASTLOG].name = MODULE_NAME;
tmm_modules[TMM_ALERTFASTLOG].ThreadInit = AlertFastLogThreadInit;
tmm_modules[TMM_ALERTFASTLOG].Func = AlertFastLog;
tmm_modules[TMM_ALERTFASTLOG].ThreadExitPrintStats = AlertFastLogExitPrintStats;
tmm_modules[TMM_ALERTFASTLOG].ThreadDeinit = AlertFastLogThreadDeinit;
tmm_modules[TMM_ALERTFASTLOG].RegisterTests = AlertFastLogRegisterTests;
OutputRegisterModule("AlertFastlog", "fast", AlertFastlogInitCtx);
OutputRegisterModule(MODULE_NAME, "fast", AlertFastLogInitCtx);
}
void TmModuleAlertFastlogIPv4Register (void) {
tmm_modules[TMM_ALERTFASTLOG4].name = "AlertFastlogIPv4";
tmm_modules[TMM_ALERTFASTLOG4].ThreadInit = AlertFastlogThreadInit;
tmm_modules[TMM_ALERTFASTLOG4].Func = AlertFastlogIPv4;
tmm_modules[TMM_ALERTFASTLOG4].ThreadExitPrintStats = AlertFastlogExitPrintStats;
tmm_modules[TMM_ALERTFASTLOG4].ThreadDeinit = AlertFastlogThreadDeinit;
void TmModuleAlertFastLogIPv4Register (void) {
tmm_modules[TMM_ALERTFASTLOG4].name = "AlertFastLogIPv4";
tmm_modules[TMM_ALERTFASTLOG4].ThreadInit = AlertFastLogThreadInit;
tmm_modules[TMM_ALERTFASTLOG4].Func = AlertFastLogIPv4;
tmm_modules[TMM_ALERTFASTLOG4].ThreadExitPrintStats = AlertFastLogExitPrintStats;
tmm_modules[TMM_ALERTFASTLOG4].ThreadDeinit = AlertFastLogThreadDeinit;
tmm_modules[TMM_ALERTFASTLOG4].RegisterTests = NULL;
}
void TmModuleAlertFastlogIPv6Register (void) {
tmm_modules[TMM_ALERTFASTLOG6].name = "AlertFastlogIPv6";
tmm_modules[TMM_ALERTFASTLOG6].ThreadInit = AlertFastlogThreadInit;
tmm_modules[TMM_ALERTFASTLOG6].Func = AlertFastlogIPv6;
tmm_modules[TMM_ALERTFASTLOG6].ThreadExitPrintStats = AlertFastlogExitPrintStats;
tmm_modules[TMM_ALERTFASTLOG6].ThreadDeinit = AlertFastlogThreadDeinit;
void TmModuleAlertFastLogIPv6Register (void) {
tmm_modules[TMM_ALERTFASTLOG6].name = "AlertFastLogIPv6";
tmm_modules[TMM_ALERTFASTLOG6].ThreadInit = AlertFastLogThreadInit;
tmm_modules[TMM_ALERTFASTLOG6].Func = AlertFastLogIPv6;
tmm_modules[TMM_ALERTFASTLOG6].ThreadExitPrintStats = AlertFastLogExitPrintStats;
tmm_modules[TMM_ALERTFASTLOG6].ThreadDeinit = AlertFastLogThreadDeinit;
tmm_modules[TMM_ALERTFASTLOG6].RegisterTests = NULL;
}
typedef struct AlertFastlogThread_ {
typedef struct AlertFastLogThread_ {
/** LogFileCtx has the pointer to the file and a mutex to allow multithreading */
LogFileCtx* file_ctx;
uint32_t alerts;
} AlertFastlogThread;
} AlertFastLogThread;
static void CreateTimeString (const struct timeval *ts, char *str, size_t size) {
time_t time = ts->tv_sec;
@ -90,9 +92,9 @@ static void CreateTimeString (const struct timeval *ts, char *str, size_t size)
(uint32_t) ts->tv_usec);
}
TmEcode AlertFastlogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode AlertFastLogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
AlertFastlogThread *aft = (AlertFastlogThread *)data;
AlertFastLogThread *aft = (AlertFastLogThread *)data;
int i;
char timebuf[64];
@ -121,9 +123,9 @@ TmEcode AlertFastlogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
return TM_ECODE_OK;
}
TmEcode AlertFastlogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode AlertFastLogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
AlertFastlogThread *aft = (AlertFastlogThread *)data;
AlertFastLogThread *aft = (AlertFastLogThread *)data;
int i;
char timebuf[64];
@ -152,24 +154,24 @@ TmEcode AlertFastlogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
return TM_ECODE_OK;
}
TmEcode AlertFastlog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode AlertFastLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
if (PKT_IS_IPV4(p)) {
return AlertFastlogIPv4(tv, p, data, pq);
return AlertFastLogIPv4(tv, p, data, pq);
} else if (PKT_IS_IPV6(p)) {
return AlertFastlogIPv6(tv, p, data, pq);
return AlertFastLogIPv6(tv, p, data, pq);
}
return TM_ECODE_OK;
}
TmEcode AlertFastlogThreadInit(ThreadVars *t, void *initdata, void **data)
TmEcode AlertFastLogThreadInit(ThreadVars *t, void *initdata, void **data)
{
AlertFastlogThread *aft = malloc(sizeof(AlertFastlogThread));
AlertFastLogThread *aft = malloc(sizeof(AlertFastLogThread));
if (aft == NULL) {
return TM_ECODE_FAILED;
}
memset(aft, 0, sizeof(AlertFastlogThread));
memset(aft, 0, sizeof(AlertFastLogThread));
if(initdata == NULL)
{
SCLogDebug("Error getting context for AlertFastLog. \"initdata\" argument NULL");
@ -181,22 +183,22 @@ TmEcode AlertFastlogThreadInit(ThreadVars *t, void *initdata, void **data)
return TM_ECODE_OK;
}
TmEcode AlertFastlogThreadDeinit(ThreadVars *t, void *data)
TmEcode AlertFastLogThreadDeinit(ThreadVars *t, void *data)
{
AlertFastlogThread *aft = (AlertFastlogThread *)data;
AlertFastLogThread *aft = (AlertFastLogThread *)data;
if (aft == NULL) {
return TM_ECODE_OK;
}
/* clear memory */
memset(aft, 0, sizeof(AlertFastlogThread));
memset(aft, 0, sizeof(AlertFastLogThread));
free(aft);
return TM_ECODE_OK;
}
void AlertFastlogExitPrintStats(ThreadVars *tv, void *data) {
AlertFastlogThread *aft = (AlertFastlogThread *)data;
void AlertFastLogExitPrintStats(ThreadVars *tv, void *data) {
AlertFastLogThread *aft = (AlertFastLogThread *)data;
if (aft == NULL) {
return;
}
@ -209,7 +211,7 @@ void AlertFastlogExitPrintStats(ThreadVars *tv, void *data) {
* \param conf The configuration node for this output.
* \return A LogFileCtx pointer on success, NULL on failure.
*/
LogFileCtx *AlertFastlogInitCtx(ConfNode *conf)
LogFileCtx *AlertFastLogInitCtx(ConfNode *conf)
{
LogFileCtx *logfile_ctx = LogFileNewCtx();
if (logfile_ctx == NULL) {
@ -220,7 +222,7 @@ LogFileCtx *AlertFastlogInitCtx(ConfNode *conf)
const char *filename = ConfNodeLookupChildValue(conf, "filename");
if (filename == NULL)
filename = DEFAULT_LOG_FILENAME;
if (AlertFastlogOpenFileCtx(logfile_ctx, filename) < 0) {
if (AlertFastLogOpenFileCtx(logfile_ctx, filename) < 0) {
LogFileFreeCtx(logfile_ctx);
return NULL;
}
@ -235,7 +237,7 @@ LogFileCtx *AlertFastlogInitCtx(ConfNode *conf)
* \param filename name of log file
* \return -1 if failure, 0 if succesful
* */
int AlertFastlogOpenFileCtx(LogFileCtx *file_ctx, const char *filename)
int AlertFastLogOpenFileCtx(LogFileCtx *file_ctx, const char *filename)
{
char log_path[PATH_MAX], *log_dir;
if (ConfGet("default-log-dir", &log_dir) != 1)
@ -289,7 +291,7 @@ int AlertFastLogTest01()
SCClassConfDeleteDummyClassificationConfigFD();
de_ctx->sig_list = SigInit(de_ctx, "alert tcp any any -> any any "
"(msg:\"Fastlog test\"; content:GET; "
"(msg:\"FastLog test\"; content:GET; "
"Classtype:unknown; sid:1;)");
result = (de_ctx->sig_list != NULL);
@ -342,7 +344,7 @@ int AlertFastLogTest02()
SCClassConfDeleteDummyClassificationConfigFD();
de_ctx->sig_list = SigInit(de_ctx, "alert tcp any any -> any any "
"(msg:\"Fastlog test\"; content:GET; "
"(msg:\"FastLog test\"; content:GET; "
"Classtype:unknown; sid:1;)");
result = (de_ctx->sig_list != NULL);
if (result == 0) printf("sig parse failed: ");

8
src/alert-fastlog.h
Unescape Escape View File

@ -4,10 +4,10 @@
#ifndef __ALERT_FASTLOG_H__
#define __ALERT_FASTLOG_H__
void TmModuleAlertFastlogRegister (void);
void TmModuleAlertFastlogIPv4Register (void);
void TmModuleAlertFastlogIPv6Register (void);
LogFileCtx *AlertFastlogInitCtx(ConfNode *);
void TmModuleAlertFastLogRegister (void);
void TmModuleAlertFastLogIPv4Register (void);
void TmModuleAlertFastLogIPv6Register (void);
LogFileCtx *AlertFastLogInitCtx(ConfNode *);
#endif /* __ALERT_FASTLOG_H__ */

7
src/alert-unified-alert.c
Unescape Escape View File

@ -32,6 +32,8 @@
#define DEFAULT_LOG_FILENAME "unified.alert"
#define MODULE_NAME "AlertUnifiedAlert"
TmEcode AlertUnifiedAlert (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertUnifiedAlertThreadInit(ThreadVars *, void *, void **);
TmEcode AlertUnifiedAlertThreadDeinit(ThreadVars *, void *);
@ -39,14 +41,13 @@ int AlertUnifiedAlertOpenFileCtx(LogFileCtx *, const char *);
void AlertUnifiedAlertRegisterTests (void);
void TmModuleAlertUnifiedAlertRegister (void) {
tmm_modules[TMM_ALERTUNIFIEDALERT].name = "AlertUnifiedAlert";
tmm_modules[TMM_ALERTUNIFIEDALERT].name = MODULE_NAME;
tmm_modules[TMM_ALERTUNIFIEDALERT].ThreadInit = AlertUnifiedAlertThreadInit;
tmm_modules[TMM_ALERTUNIFIEDALERT].Func = AlertUnifiedAlert;
tmm_modules[TMM_ALERTUNIFIEDALERT].ThreadDeinit = AlertUnifiedAlertThreadDeinit;
tmm_modules[TMM_ALERTUNIFIEDALERT].RegisterTests = AlertUnifiedAlertRegisterTests;
OutputRegisterModule("AlertUnifiedAlert", "unified-alert",
AlertUnifiedAlertInitCtx);
OutputRegisterModule(MODULE_NAME, "unified-alert", AlertUnifiedAlertInitCtx);
}
typedef struct AlertUnifiedAlertThread_ {

7
src/alert-unified-log.c
Unescape Escape View File

@ -34,6 +34,8 @@
#define DEFAULT_LOG_FILENAME "unified.log"
#define MODULE_NAME "AlertUnifiedLog"
TmEcode AlertUnifiedLog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertUnifiedLogThreadInit(ThreadVars *, void *, void **);
TmEcode AlertUnifiedLogThreadDeinit(ThreadVars *, void *);
@ -41,14 +43,13 @@ int AlertUnifiedLogOpenFileCtx(LogFileCtx *, const char *);
void AlertUnifiedLogRegisterTests(void);
void TmModuleAlertUnifiedLogRegister (void) {
tmm_modules[TMM_ALERTUNIFIEDLOG].name = "AlertUnifiedLog";
tmm_modules[TMM_ALERTUNIFIEDLOG].name = MODULE_NAME;
tmm_modules[TMM_ALERTUNIFIEDLOG].ThreadInit = AlertUnifiedLogThreadInit;
tmm_modules[TMM_ALERTUNIFIEDLOG].Func = AlertUnifiedLog;
tmm_modules[TMM_ALERTUNIFIEDLOG].ThreadDeinit = AlertUnifiedLogThreadDeinit;
tmm_modules[TMM_ALERTUNIFIEDLOG].RegisterTests = AlertUnifiedLogRegisterTests;
OutputRegisterModule("AlertUnifiedLog", "unified-log",
AlertUnifiedLogInitCtx);
OutputRegisterModule(MODULE_NAME, "unified-log", AlertUnifiedLogInitCtx);
}
typedef struct AlertUnifiedLogThread_ {

7
src/alert-unified2-alert.c
Unescape Escape View File

@ -124,15 +124,16 @@ typedef struct AlertUnified2Packet_ {
uint8_t packet_data[4]; /**< packet data */
} Unified2Packet;
#define MODULE_NAME "Unified2Alert"
void TmModuleUnified2AlertRegister (void) {
tmm_modules[TMM_ALERTUNIFIED2ALERT].name = "Unified2Alert";
tmm_modules[TMM_ALERTUNIFIED2ALERT].name = MODULE_NAME;
tmm_modules[TMM_ALERTUNIFIED2ALERT].ThreadInit = Unified2AlertThreadInit;
tmm_modules[TMM_ALERTUNIFIED2ALERT].Func = Unified2Alert;
tmm_modules[TMM_ALERTUNIFIED2ALERT].ThreadDeinit = Unified2AlertThreadDeinit;
tmm_modules[TMM_ALERTUNIFIED2ALERT].RegisterTests = Unified2RegisterTests;
OutputRegisterModule("Unified2Alert", "unified2-alert",
Unified2AlertInitCtx);
OutputRegisterModule(MODULE_NAME, "unified2-alert", Unified2AlertInitCtx);
}
/**

100
src/log-httplog.c
Unescape Escape View File

@ -25,48 +25,50 @@
#define DEFAULT_LOG_FILENAME "http.log"
TmEcode LogHttplog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode LogHttplogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode LogHttplogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode LogHttplogThreadInit(ThreadVars *, void *, void **);
TmEcode LogHttplogThreadDeinit(ThreadVars *, void *);
void LogHttplogExitPrintStats(ThreadVars *, void *);
int LogHttplogOpenFileCtx(LogFileCtx* , const char *);
void TmModuleLogHttplogRegister (void) {
tmm_modules[TMM_LOGHTTPLOG].name = "LogHttplog";
tmm_modules[TMM_LOGHTTPLOG].ThreadInit = LogHttplogThreadInit;
tmm_modules[TMM_LOGHTTPLOG].Func = LogHttplog;
tmm_modules[TMM_LOGHTTPLOG].ThreadExitPrintStats = LogHttplogExitPrintStats;
tmm_modules[TMM_LOGHTTPLOG].ThreadDeinit = LogHttplogThreadDeinit;
#define MODULE_NAME "LogHttpLog"
TmEcode LogHttpLog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode LogHttpLogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode LogHttpLogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode LogHttpLogThreadInit(ThreadVars *, void *, void **);
TmEcode LogHttpLogThreadDeinit(ThreadVars *, void *);
void LogHttpLogExitPrintStats(ThreadVars *, void *);
int LogHttpLogOpenFileCtx(LogFileCtx* , const char *);
void TmModuleLogHttpLogRegister (void) {
tmm_modules[TMM_LOGHTTPLOG].name = MODULE_NAME;
tmm_modules[TMM_LOGHTTPLOG].ThreadInit = LogHttpLogThreadInit;
tmm_modules[TMM_LOGHTTPLOG].Func = LogHttpLog;
tmm_modules[TMM_LOGHTTPLOG].ThreadExitPrintStats = LogHttpLogExitPrintStats;
tmm_modules[TMM_LOGHTTPLOG].ThreadDeinit = LogHttpLogThreadDeinit;
tmm_modules[TMM_LOGHTTPLOG].RegisterTests = NULL;
OutputRegisterModule("LogHttplog", "http-log", LogHttplogInitCtx);
OutputRegisterModule(MODULE_NAME, "http-log", LogHttpLogInitCtx);
}
void TmModuleLogHttplogIPv4Register (void) {
tmm_modules[TMM_LOGHTTPLOG4].name = "LogHttplogIPv4";
tmm_modules[TMM_LOGHTTPLOG4].ThreadInit = LogHttplogThreadInit;
tmm_modules[TMM_LOGHTTPLOG4].Func = LogHttplogIPv4;
tmm_modules[TMM_LOGHTTPLOG4].ThreadExitPrintStats = LogHttplogExitPrintStats;
tmm_modules[TMM_LOGHTTPLOG4].ThreadDeinit = LogHttplogThreadDeinit;
void TmModuleLogHttpLogIPv4Register (void) {
tmm_modules[TMM_LOGHTTPLOG4].name = "LogHttpLogIPv4";
tmm_modules[TMM_LOGHTTPLOG4].ThreadInit = LogHttpLogThreadInit;
tmm_modules[TMM_LOGHTTPLOG4].Func = LogHttpLogIPv4;
tmm_modules[TMM_LOGHTTPLOG4].ThreadExitPrintStats = LogHttpLogExitPrintStats;
tmm_modules[TMM_LOGHTTPLOG4].ThreadDeinit = LogHttpLogThreadDeinit;
tmm_modules[TMM_LOGHTTPLOG4].RegisterTests = NULL;
}
void TmModuleLogHttplogIPv6Register (void) {
tmm_modules[TMM_LOGHTTPLOG6].name = "LogHttplogIPv6";
tmm_modules[TMM_LOGHTTPLOG6].ThreadInit = LogHttplogThreadInit;
tmm_modules[TMM_LOGHTTPLOG6].Func = LogHttplogIPv6;
tmm_modules[TMM_LOGHTTPLOG6].ThreadExitPrintStats = LogHttplogExitPrintStats;
tmm_modules[TMM_LOGHTTPLOG6].ThreadDeinit = LogHttplogThreadDeinit;
void TmModuleLogHttpLogIPv6Register (void) {
tmm_modules[TMM_LOGHTTPLOG6].name = "LogHttpLogIPv6";
tmm_modules[TMM_LOGHTTPLOG6].ThreadInit = LogHttpLogThreadInit;
tmm_modules[TMM_LOGHTTPLOG6].Func = LogHttpLogIPv6;
tmm_modules[TMM_LOGHTTPLOG6].ThreadExitPrintStats = LogHttpLogExitPrintStats;
tmm_modules[TMM_LOGHTTPLOG6].ThreadDeinit = LogHttpLogThreadDeinit;
tmm_modules[TMM_LOGHTTPLOG6].RegisterTests = NULL;
}
typedef struct LogHttplogThread_ {
typedef struct LogHttpLogThread_ {
LogFileCtx *file_ctx;
/** LogFileCtx has the pointer to the file and a mutex to allow multithreading */
uint32_t uri_cnt;
} LogHttplogThread;
} LogHttpLogThread;
static void CreateTimeString (const struct timeval *ts, char *str, size_t size) {
time_t time = ts->tv_sec;
@ -79,9 +81,9 @@ static void CreateTimeString (const struct timeval *ts, char *str, size_t size)
(uint32_t) ts->tv_usec);
}
TmEcode LogHttplogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode LogHttpLogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
LogHttplogThread *aft = (LogHttplogThread *)data;
LogHttpLogThread *aft = (LogHttpLogThread *)data;
int i;
char timebuf[64];
@ -122,9 +124,9 @@ TmEcode LogHttplogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
return TM_ECODE_OK;
}
TmEcode LogHttplogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode LogHttpLogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
LogHttplogThread *aft = (LogHttplogThread *)data;
LogHttpLogThread *aft = (LogHttpLogThread *)data;
int i;
char timebuf[64];
@ -165,27 +167,27 @@ TmEcode LogHttplogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
return TM_ECODE_OK;
}
TmEcode LogHttplog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
TmEcode LogHttpLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{
if (!(PKT_IS_TCP(p)))
return TM_ECODE_OK;
if (PKT_IS_IPV4(p)) {
return LogHttplogIPv4(tv, p, data, pq);
return LogHttpLogIPv4(tv, p, data, pq);
} else if (PKT_IS_IPV6(p)) {
return LogHttplogIPv6(tv, p, data, pq);
return LogHttpLogIPv6(tv, p, data, pq);
}
return TM_ECODE_OK;
}
TmEcode LogHttplogThreadInit(ThreadVars *t, void *initdata, void **data)
TmEcode LogHttpLogThreadInit(ThreadVars *t, void *initdata, void **data)
{
LogHttplogThread *aft = malloc(sizeof(LogHttplogThread));
LogHttpLogThread *aft = malloc(sizeof(LogHttpLogThread));
if (aft == NULL) {
return TM_ECODE_FAILED;
}
memset(aft, 0, sizeof(LogHttplogThread));
memset(aft, 0, sizeof(LogHttpLogThread));
if(initdata == NULL)
{
@ -199,22 +201,22 @@ TmEcode LogHttplogThreadInit(ThreadVars *t, void *initdata, void **data)
return TM_ECODE_OK;
}
TmEcode LogHttplogThreadDeinit(ThreadVars *t, void *data)
TmEcode LogHttpLogThreadDeinit(ThreadVars *t, void *data)
{
LogHttplogThread *aft = (LogHttplogThread *)data;
LogHttpLogThread *aft = (LogHttpLogThread *)data;
if (aft == NULL) {
return TM_ECODE_OK;
}
/* clear memory */
memset(aft, 0, sizeof(LogHttplogThread));
memset(aft, 0, sizeof(LogHttpLogThread));
free(aft);
return TM_ECODE_OK;
}
void LogHttplogExitPrintStats(ThreadVars *tv, void *data) {
LogHttplogThread *aft = (LogHttplogThread *)data;
void LogHttpLogExitPrintStats(ThreadVars *tv, void *data) {
LogHttpLogThread *aft = (LogHttpLogThread *)data;
if (aft == NULL) {
return;
}
@ -226,14 +228,14 @@ void LogHttplogExitPrintStats(ThreadVars *tv, void *data) {
* \param conf Pointer to ConfNode containing this loggers configuration.
* \return NULL if failure, LogFileCtx* to the file_ctx if succesful
* */
LogFileCtx *LogHttplogInitCtx(ConfNode *conf)
LogFileCtx *LogHttpLogInitCtx(ConfNode *conf)
{
int ret=0;
LogFileCtx* file_ctx=LogFileNewCtx();
if(file_ctx == NULL)
{
SCLogError(SC_ERR_HTTP_LOG_GENERIC_ERROR, "LogHttplogInitCtx: Couldn't "
SCLogError(SC_ERR_HTTP_LOG_GENERIC_ERROR, "LogHttpLogInitCtx: Couldn't "
"create new file_ctx");
return NULL;
}
@ -242,8 +244,8 @@ LogFileCtx *LogHttplogInitCtx(ConfNode *conf)
if (filename == NULL)
filename = DEFAULT_LOG_FILENAME;
/** fill the new LogFileCtx with the specific LogHttplog configuration */
ret=LogHttplogOpenFileCtx(file_ctx, filename);
/** fill the new LogFileCtx with the specific LogHttpLog configuration */
ret=LogHttpLogOpenFileCtx(file_ctx, filename);
if(ret < 0)
return NULL;
@ -256,7 +258,7 @@ LogFileCtx *LogHttplogInitCtx(ConfNode *conf)
* \param config_file for loading separate configs
* \return -1 if failure, 0 if succesful
* */
int LogHttplogOpenFileCtx(LogFileCtx *file_ctx, const char *filename)
int LogHttpLogOpenFileCtx(LogFileCtx *file_ctx, const char *filename)
{
char log_path[PATH_MAX], *log_dir;
if (ConfGet("default-log-dir", &log_dir) != 1)

8
src/log-httplog.h
Unescape Escape View File

@ -3,10 +3,10 @@
#ifndef __LOG_HTTPLOG_H__
#define __LOG_HTTPLOG_H__
void TmModuleLogHttplogRegister (void);
void TmModuleLogHttplogIPv4Register (void);
void TmModuleLogHttplogIPv6Register (void);
LogFileCtx *LogHttplogInitCtx(ConfNode *);
void TmModuleLogHttpLogRegister (void);
void TmModuleLogHttpLogIPv4Register (void);
void TmModuleLogHttpLogIPv6Register (void);
LogFileCtx *LogHttpLogInitCtx(ConfNode *);
#endif /* __LOG_HTTPLOG_H__ */

14
src/suricata.c
Unescape Escape View File

@ -526,18 +526,18 @@ int main(int argc, char **argv)
TmModuleReceivePcapFileRegister();
TmModuleDecodePcapFileRegister();
TmModuleDetectRegister();
TmModuleAlertFastlogRegister();
TmModuleAlertDebuglogRegister();
TmModuleAlertFastLogRegister();
TmModuleAlertDebugLogRegister();
TmModuleRespondRejectRegister();
TmModuleAlertFastlogIPv4Register();
TmModuleAlertFastlogIPv6Register();
TmModuleAlertFastLogIPv4Register();
TmModuleAlertFastLogIPv6Register();
TmModuleAlertUnifiedLogRegister();
TmModuleAlertUnifiedAlertRegister();
TmModuleUnified2AlertRegister();
TmModuleStreamTcpRegister();
TmModuleLogHttplogRegister();
TmModuleLogHttplogIPv4Register();
TmModuleLogHttplogIPv6Register();
TmModuleLogHttpLogRegister();
TmModuleLogHttpLogIPv4Register();
TmModuleLogHttpLogIPv6Register();
TmModuleDebugList();
#ifdef UNITTESTS

Write Preview
Loading…
Cancel
Save