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

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

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

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

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

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

@ -4,10 +4,10 @@
#ifndef __ALERT_FASTLOG_H__ #ifndef __ALERT_FASTLOG_H__
#define __ALERT_FASTLOG_H__ #define __ALERT_FASTLOG_H__
void TmModuleAlertFastlogRegister (void); void TmModuleAlertFastLogRegister (void);
void TmModuleAlertFastlogIPv4Register (void); void TmModuleAlertFastLogIPv4Register (void);
void TmModuleAlertFastlogIPv6Register (void); void TmModuleAlertFastLogIPv6Register (void);
LogFileCtx *AlertFastlogInitCtx(ConfNode *); LogFileCtx *AlertFastLogInitCtx(ConfNode *);
#endif /* __ALERT_FASTLOG_H__ */ #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 DEFAULT_LOG_FILENAME "unified.alert"
#define MODULE_NAME "AlertUnifiedAlert"
TmEcode AlertUnifiedAlert (ThreadVars *, Packet *, void *, PacketQueue *); TmEcode AlertUnifiedAlert (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertUnifiedAlertThreadInit(ThreadVars *, void *, void **); TmEcode AlertUnifiedAlertThreadInit(ThreadVars *, void *, void **);
TmEcode AlertUnifiedAlertThreadDeinit(ThreadVars *, void *); TmEcode AlertUnifiedAlertThreadDeinit(ThreadVars *, void *);
@ -39,14 +41,13 @@ int AlertUnifiedAlertOpenFileCtx(LogFileCtx *, const char *);
void AlertUnifiedAlertRegisterTests (void); void AlertUnifiedAlertRegisterTests (void);
void TmModuleAlertUnifiedAlertRegister (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].ThreadInit = AlertUnifiedAlertThreadInit;
tmm_modules[TMM_ALERTUNIFIEDALERT].Func = AlertUnifiedAlert; tmm_modules[TMM_ALERTUNIFIEDALERT].Func = AlertUnifiedAlert;
tmm_modules[TMM_ALERTUNIFIEDALERT].ThreadDeinit = AlertUnifiedAlertThreadDeinit; tmm_modules[TMM_ALERTUNIFIEDALERT].ThreadDeinit = AlertUnifiedAlertThreadDeinit;
tmm_modules[TMM_ALERTUNIFIEDALERT].RegisterTests = AlertUnifiedAlertRegisterTests; tmm_modules[TMM_ALERTUNIFIEDALERT].RegisterTests = AlertUnifiedAlertRegisterTests;
OutputRegisterModule("AlertUnifiedAlert", "unified-alert", OutputRegisterModule(MODULE_NAME, "unified-alert", AlertUnifiedAlertInitCtx);
AlertUnifiedAlertInitCtx);
} }
typedef struct AlertUnifiedAlertThread_ { typedef struct AlertUnifiedAlertThread_ {

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

@ -34,6 +34,8 @@
#define DEFAULT_LOG_FILENAME "unified.log" #define DEFAULT_LOG_FILENAME "unified.log"
#define MODULE_NAME "AlertUnifiedLog"
TmEcode AlertUnifiedLog (ThreadVars *, Packet *, void *, PacketQueue *); TmEcode AlertUnifiedLog (ThreadVars *, Packet *, void *, PacketQueue *);
TmEcode AlertUnifiedLogThreadInit(ThreadVars *, void *, void **); TmEcode AlertUnifiedLogThreadInit(ThreadVars *, void *, void **);
TmEcode AlertUnifiedLogThreadDeinit(ThreadVars *, void *); TmEcode AlertUnifiedLogThreadDeinit(ThreadVars *, void *);
@ -41,14 +43,13 @@ int AlertUnifiedLogOpenFileCtx(LogFileCtx *, const char *);
void AlertUnifiedLogRegisterTests(void); void AlertUnifiedLogRegisterTests(void);
void TmModuleAlertUnifiedLogRegister (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].ThreadInit = AlertUnifiedLogThreadInit;
tmm_modules[TMM_ALERTUNIFIEDLOG].Func = AlertUnifiedLog; tmm_modules[TMM_ALERTUNIFIEDLOG].Func = AlertUnifiedLog;
tmm_modules[TMM_ALERTUNIFIEDLOG].ThreadDeinit = AlertUnifiedLogThreadDeinit; tmm_modules[TMM_ALERTUNIFIEDLOG].ThreadDeinit = AlertUnifiedLogThreadDeinit;
tmm_modules[TMM_ALERTUNIFIEDLOG].RegisterTests = AlertUnifiedLogRegisterTests; tmm_modules[TMM_ALERTUNIFIEDLOG].RegisterTests = AlertUnifiedLogRegisterTests;
OutputRegisterModule("AlertUnifiedLog", "unified-log", OutputRegisterModule(MODULE_NAME, "unified-log", AlertUnifiedLogInitCtx);
AlertUnifiedLogInitCtx);
} }
typedef struct AlertUnifiedLogThread_ { 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 */ uint8_t packet_data[4]; /**< packet data */
} Unified2Packet; } Unified2Packet;
#define MODULE_NAME "Unified2Alert"
void TmModuleUnified2AlertRegister (void) { 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].ThreadInit = Unified2AlertThreadInit;
tmm_modules[TMM_ALERTUNIFIED2ALERT].Func = Unified2Alert; tmm_modules[TMM_ALERTUNIFIED2ALERT].Func = Unified2Alert;
tmm_modules[TMM_ALERTUNIFIED2ALERT].ThreadDeinit = Unified2AlertThreadDeinit; tmm_modules[TMM_ALERTUNIFIED2ALERT].ThreadDeinit = Unified2AlertThreadDeinit;
tmm_modules[TMM_ALERTUNIFIED2ALERT].RegisterTests = Unified2RegisterTests; tmm_modules[TMM_ALERTUNIFIED2ALERT].RegisterTests = Unified2RegisterTests;
OutputRegisterModule("Unified2Alert", "unified2-alert", OutputRegisterModule(MODULE_NAME, "unified2-alert", Unified2AlertInitCtx);
Unified2AlertInitCtx);
} }
/** /**

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

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

14
src/suricata.c
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save