support for thread exit constants

src/alert-debuglog.c

@@ -28,11 +28,11 @@
 
 #define DEFAULT_LOG_FILENAME "alert-debug.log"
 
-int AlertDebuglog (ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertDebuglogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertDebuglogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertDebuglogThreadInit(ThreadVars *, void*, void **);
-int AlertDebuglogThreadDeinit(ThreadVars *, void *);
+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* , char *);
 
@@ -62,14 +62,14 @@ static void CreateTimeString (const struct timeval *ts, char *str, size_t size)
         (uint32_t) ts->tv_usec);
 }
 
-int AlertDebuglogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode AlertDebuglogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
     int i;
     char timebuf[64];
 
     if (p->alerts.cnt == 0)
-        return 0;
+        return TM_ECODE_OK;
 
     CreateTimeString(&p->ts, timebuf, sizeof(timebuf));
 
@@ -139,17 +139,17 @@ int AlertDebuglogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     fflush(aft->file_ctx->fp);
     mutex_unlock(&aft->file_ctx->fp_mutex);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertDebuglogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode AlertDebuglogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
     int i;
     char timebuf[64];
 
     if (p->alerts.cnt == 0)
-        return 0;
+        return TM_ECODE_OK;
 
     aft->alerts += p->alerts.cnt;
 
@@ -169,10 +169,10 @@ int AlertDebuglogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     fflush(aft->file_ctx->fp);
     mutex_unlock(&aft->file_ctx->fp_mutex);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int 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);
@@ -180,41 +180,41 @@ int AlertDebuglog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
         return AlertDebuglogIPv6(tv, p, data, pq);
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertDebuglogThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode AlertDebuglogThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     AlertDebuglogThread *aft = malloc(sizeof(AlertDebuglogThread));
     if (aft == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(aft, 0, sizeof(AlertDebuglogThread));
 
     if(initdata == NULL)
     {
         printf("Error getting context for the file\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /** Use the Ouptut Context (file pointer and mutex) */
     aft->file_ctx=(LogFileCtx *) initdata;
 
     *data = (void *)aft;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertDebuglogThreadDeinit(ThreadVars *t, void *data)
+TmEcode AlertDebuglogThreadDeinit(ThreadVars *t, void *data)
 {
     AlertDebuglogThread *aft = (AlertDebuglogThread *)data;
     if (aft == NULL) {
-        return 0;
+        return TM_ECODE_OK;
     }
 
     /* clear memory */
     memset(aft, 0, sizeof(AlertDebuglogThread));
 
     free(aft);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void AlertDebuglogExitPrintStats(ThreadVars *tv, void *data) {

src/alert-fastlog.c

@@ -26,11 +26,11 @@
 
 #define DEFAULT_LOG_FILENAME "fast.log"
 
-int AlertFastlog (ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertFastlogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertFastlogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertFastlogThreadInit(ThreadVars *, void *, void **);
-int AlertFastlogThreadDeinit(ThreadVars *, void *);
+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 *, char *);
 
@@ -78,14 +78,14 @@ static void CreateTimeString (const struct timeval *ts, char *str, size_t size)
         (uint32_t) ts->tv_usec);
 }
 
-int AlertFastlogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode AlertFastlogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     AlertFastlogThread *aft = (AlertFastlogThread *)data;
     int i;
     char timebuf[64];
 
     if (p->alerts.cnt == 0)
-        return 0;
+        return TM_ECODE_OK;
 
     aft->alerts += p->alerts.cnt;
 
@@ -106,17 +106,17 @@ int AlertFastlogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     fflush(aft->file_ctx->fp);
     mutex_unlock(&aft->file_ctx->fp_mutex);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertFastlogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode AlertFastlogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     AlertFastlogThread *aft = (AlertFastlogThread *)data;
     int i;
     char timebuf[64];
 
     if (p->alerts.cnt == 0)
-        return 0;
+        return TM_ECODE_OK;
 
     aft->alerts += p->alerts.cnt;
 
@@ -138,10 +138,10 @@ int AlertFastlogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 
     mutex_unlock(&aft->file_ctx->fp_mutex);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int 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);
@@ -149,39 +149,39 @@ int AlertFastlog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
         return AlertFastlogIPv6(tv, p, data, pq);
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertFastlogThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode AlertFastlogThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     AlertFastlogThread *aft = malloc(sizeof(AlertFastlogThread));
     if (aft == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(aft, 0, sizeof(AlertFastlogThread));
     if(initdata == NULL)
     {
         printf("Error getting context for the file\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /** Use the Ouptut Context (file pointer and mutex) */
     aft->file_ctx = (LogFileCtx*) initdata;
     *data = (void *)aft;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertFastlogThreadDeinit(ThreadVars *t, void *data)
+TmEcode AlertFastlogThreadDeinit(ThreadVars *t, void *data)
 {
     AlertFastlogThread *aft = (AlertFastlogThread *)data;
     if (aft == NULL) {
-        return 0;
+        return TM_ECODE_OK;
     }
 
     /* clear memory */
     memset(aft, 0, sizeof(AlertFastlogThread));
 
     free(aft);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void AlertFastlogExitPrintStats(ThreadVars *tv, void *data) {

src/alert-unified-alert.c

@@ -26,9 +26,9 @@
 
 #define DEFAULT_LOG_FILENAME "unified.alert"
 
-int AlertUnifiedAlert (ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertUnifiedAlertThreadInit(ThreadVars *, void *, void **);
-int AlertUnifiedAlertThreadDeinit(ThreadVars *, void *);
+TmEcode AlertUnifiedAlert (ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode AlertUnifiedAlertThreadInit(ThreadVars *, void *, void **);
+TmEcode AlertUnifiedAlertThreadDeinit(ThreadVars *, void *);
 int AlertUnifiedAlertOpenFileCtx(LogFileCtx *, char *);
 
 void TmModuleAlertUnifiedAlertRegister (void) {
@@ -125,7 +125,7 @@ int AlertUnifiedAlertRotateFile(ThreadVars *t, AlertUnifiedAlertThread *aun) {
     return 0;
 }
 
-int AlertUnifiedAlert (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode AlertUnifiedAlert (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     AlertUnifiedAlertThread *aun = (AlertUnifiedAlertThread *)data;
     AlertUnifiedAlertPacketHeader hdr;
@@ -134,7 +134,7 @@ int AlertUnifiedAlert (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 
     /* the unified1 format only supports IPv4. */
     if (p->alerts.cnt == 0 || !PKT_IS_IPV4(p))
-        return 0;
+        return TM_ECODE_OK;
 
     /* if we have no ethernet header (e.g. when using nfq), we have to create
      * one ourselves. */
@@ -148,7 +148,7 @@ int AlertUnifiedAlert (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
         if (AlertUnifiedAlertRotateFile(tv,aun) < 0)
         {
             mutex_unlock(&aun->file_ctx->fp_mutex);
-            return -1;
+            return TM_ECODE_FAILED;
         }
     }
     mutex_unlock(&aun->file_ctx->fp_mutex);
@@ -178,28 +178,28 @@ int AlertUnifiedAlert (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     ret = fwrite(&hdr, sizeof(hdr), 1, aun->file_ctx->fp);
     if (ret != 1) {
         printf("Error: fwrite failed: %s\n", strerror(errno));
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /* force writing to disk so barnyard will not read half
      * written records and choke. */
     fflush(aun->file_ctx->fp);
 
     aun->size_current += sizeof(hdr);
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertUnifiedAlertThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode AlertUnifiedAlertThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     AlertUnifiedAlertThread *aun = malloc(sizeof(AlertUnifiedAlertThread));
     if (aun == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(aun, 0, sizeof(AlertUnifiedAlertThread));
 
     if(initdata == NULL)
     {
         printf("Error getting context for the file\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /** Use the Ouptut Context (file pointer and mutex) */
     aun->file_ctx = (LogFileCtx*) initdata;
@@ -208,17 +208,17 @@ int AlertUnifiedAlertThreadInit(ThreadVars *t, void *initdata, void **data)
     int ret = AlertUnifiedAlertWriteFileHeader(t, aun);
     if (ret != 0) {
         printf("Error: AlertUnifiedLogWriteFileHeader failed.\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     /* XXX make configurable */
     aun->size_limit = 10 * 1024 * 1024;
 
     *data = (void *)aun;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertUnifiedAlertThreadDeinit(ThreadVars *t, void *data)
+TmEcode AlertUnifiedAlertThreadDeinit(ThreadVars *t, void *data)
 {
     AlertUnifiedAlertThread *aun = (AlertUnifiedAlertThread *)data;
     if (aun == NULL) {
@@ -228,7 +228,7 @@ int AlertUnifiedAlertThreadDeinit(ThreadVars *t, void *data)
     /* clear memory */
     memset(aun, 0, sizeof(AlertUnifiedAlertThread));
     free(aun);
-    return 0;
+    return TM_ECODE_OK;
 
 error:
     /* clear memory */
@@ -236,7 +236,7 @@ error:
         memset(aun, 0, sizeof(AlertUnifiedAlertThread));
         free(aun);
     }
-    return -1;
+    return TM_ECODE_FAILED;
 }
 
 

src/alert-unified-log.c

@@ -26,9 +26,9 @@
 
 #define DEFAULT_LOG_FILENAME "unified.log"
 
-int AlertUnifiedLog (ThreadVars *, Packet *, void *, PacketQueue *);
-int AlertUnifiedLogThreadInit(ThreadVars *, void *, void **);
-int AlertUnifiedLogThreadDeinit(ThreadVars *, void *);
+TmEcode AlertUnifiedLog (ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode AlertUnifiedLogThreadInit(ThreadVars *, void *, void **);
+TmEcode AlertUnifiedLogThreadDeinit(ThreadVars *, void *);
 int AlertUnifiedLogOpenFileCtx(LogFileCtx *, char *);
 
 void TmModuleAlertUnifiedLogRegister (void) {
@@ -127,7 +127,7 @@ int AlertUnifiedLogRotateFile(ThreadVars *t, AlertUnifiedLogThread *aun) {
     return 0;
 }
 
-int AlertUnifiedLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode AlertUnifiedLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     AlertUnifiedLogThread *aun = (AlertUnifiedLogThread *)data;
     AlertUnifiedLogPacketHeader hdr;
@@ -138,7 +138,7 @@ int AlertUnifiedLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 
     /* the unified1 format only supports IPv4. */
     if (p->alerts.cnt == 0 || !PKT_IS_IPV4(p))
-        return 0;
+        return TM_ECODE_OK;
 
     /* if we have no ethernet header (e.g. when using nfq), we have to create
      * one ourselves. */
@@ -154,7 +154,7 @@ int AlertUnifiedLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
         if (AlertUnifiedLogRotateFile(tv,aun) < 0)
         {
             mutex_unlock(&aun->file_ctx->fp_mutex);
-            return -1;
+            return TM_ECODE_FAILED;
         }
     }
     mutex_unlock(&aun->file_ctx->fp_mutex);
@@ -195,27 +195,27 @@ int AlertUnifiedLog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     ret = fwrite(buf, buflen, 1, aun->file_ctx->fp);
     if (ret != 1) {
         printf("Error: fwrite failed: %s\n", strerror(errno));
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /* force writing to disk so barnyard will not read half
      * written records and choke. */
     fflush(aun->file_ctx->fp);
 
     aun->size_current += buflen;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertUnifiedLogThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode AlertUnifiedLogThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     AlertUnifiedLogThread *aun = malloc(sizeof(AlertUnifiedLogThread));
     if (aun == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(aun, 0, sizeof(AlertUnifiedLogThread));
     if(initdata == NULL)
     {
         printf("Error getting context for the file\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /** Use the Ouptut Context (file pointer and mutex) */
     aun->file_ctx = (LogFileCtx*) initdata;
@@ -224,17 +224,17 @@ int AlertUnifiedLogThreadInit(ThreadVars *t, void *initdata, void **data)
     int ret = AlertUnifiedLogWriteFileHeader(t, aun);
     if (ret != 0) {
         printf("Error: AlertUnifiedLogWriteFileHeader failed.\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     /* XXX make configurable */
     aun->size_limit = 1 * 1024 * 1024;
 
     *data = (void *)aun;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int AlertUnifiedLogThreadDeinit(ThreadVars *t, void *data)
+TmEcode AlertUnifiedLogThreadDeinit(ThreadVars *t, void *data)
 {
     AlertUnifiedLogThread *aun = (AlertUnifiedLogThread *)data;
     if (aun == NULL) {
@@ -244,7 +244,7 @@ int AlertUnifiedLogThreadDeinit(ThreadVars *t, void *data)
     /* clear memory */
     memset(aun, 0, sizeof(AlertUnifiedLogThread));
     free(aun);
-    return 0;
+    return TM_ECODE_OK;
 
 error:
     /* clear memory */
@@ -253,7 +253,7 @@ error:
         free(aun);
     }
     printf("AlertUnifiedLogThreadDeinit done (error)\n");
-    return -1;
+    return TM_ECODE_FAILED;
 }
 
 

src/alert-unified2-alert.c

@@ -21,9 +21,9 @@
 #include "util-debug.h"
 
 /*prototypes*/
-int Unified2Alert (ThreadVars *, Packet *, void *, PacketQueue *);
-int Unified2AlertThreadInit(ThreadVars *, void *, void **);
-int Unified2AlertThreadDeinit(ThreadVars *, void *);
+TmEcode Unified2Alert (ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode Unified2AlertThreadInit(ThreadVars *, void *, void **);
+TmEcode Unified2AlertThreadDeinit(ThreadVars *, void *);
 int Unified2IPv4TypeAlert(ThreadVars *, Packet *, void *, PacketQueue *);
 int Unified2IPv6TypeAlert(ThreadVars *, Packet *, void *, PacketQueue *);
 int Unified2PacketTypeAlert(ThreadVars *, Packet *, void *);
@@ -156,19 +156,21 @@ int Unified2AlertRotateFile(ThreadVars *t, Unified2AlertThread *aun) {
     return 0;
 }
 
-int Unified2Alert (ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
+TmEcode Unified2Alert (ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
 {
     if(PKT_IS_IPV4(p))  {
-        Unified2IPv4TypeAlert (t, p, data, pq);
-        return 0;
+        if (Unified2IPv4TypeAlert (t, p, data, pq))
+	    return TM_ECODE_FAILED;
+        return TM_ECODE_OK;
     }
 
     if(PKT_IS_IPV6(p))  {
-        Unified2IPv6TypeAlert (t, p, data, pq);
-        return 0;
+        if (Unified2IPv6TypeAlert (t, p, data, pq))
+	    return TM_ECODE_FAILED;
+        return TM_ECODE_OK;
     }
 
-    return -1;
+    return TM_ECODE_FAILED;
 }
 
 /**
@@ -469,17 +471,17 @@ int Unified2IPv4TypeAlert (ThreadVars *tv, Packet *p, void *data, PacketQueue *p
  *  \retval -1 on failure
  */
 
-int Unified2AlertThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode Unified2AlertThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     Unified2AlertThread *aun = malloc(sizeof(Unified2AlertThread));
     if (aun == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(aun, 0, sizeof(Unified2AlertThread));
     if(initdata == NULL)
     {
         printf("Error getting context for the file\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /** Use the Ouptut Context (file pointer and mutex) */
     aun->file_ctx = (LogFileCtx*) initdata;
@@ -488,7 +490,7 @@ int Unified2AlertThreadInit(ThreadVars *t, void *initdata, void **data)
     aun->size_limit = 10 * 1024 * 1024;
 
     *data = (void *)aun;
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -500,7 +502,7 @@ int Unified2AlertThreadInit(ThreadVars *t, void *initdata, void **data)
  *  \retval -1 on failure
  */
 
-int Unified2AlertThreadDeinit(ThreadVars *t, void *data)
+TmEcode Unified2AlertThreadDeinit(ThreadVars *t, void *data)
 {
     Unified2AlertThread *aun = (Unified2AlertThread *)data;
     if (aun == NULL) {
@@ -510,7 +512,7 @@ int Unified2AlertThreadDeinit(ThreadVars *t, void *data)
     /* clear memory */
     memset(aun, 0, sizeof(Unified2AlertThread));
     free(aun);
-    return 0;
+    return TM_ECODE_OK;
 
 error:
     /* clear memory */
@@ -518,7 +520,7 @@ error:
         memset(aun, 0, sizeof(Unified2AlertThread));
         free(aun);
     }
-    return -1;
+    return TM_ECODE_FAILED;
 }
 
 /** \brief Create a new file_ctx from config_file (if specified)
@@ -648,10 +650,10 @@ static int Unified2Test01 (void)   {
     if(lf == NULL)
         return 0;
     ret = Unified2AlertThreadInit(&tv, lf, &data);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
     ret = Unified2Alert(&tv, &p, data, &pq);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
     ret = Unified2AlertThreadDeinit(&tv, data);
     if(ret == -1)
@@ -716,7 +718,7 @@ static int Unified2Test02 (void)   {
     if(ret == -1)
         return 0;
     ret = Unified2Alert(&tv, &p, data, &pq);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
     ret = Unified2AlertThreadDeinit(&tv, data);
     if(ret == -1)
@@ -788,7 +790,7 @@ static int Unified2Test03 (void)   {
     if(ret == -1)
         return 0;
     ret = Unified2Alert(&tv, &p, data, &pq);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
     ret = Unified2AlertThreadDeinit(&tv, data);
     if(ret == -1)
@@ -848,7 +850,7 @@ static int Unified2Test04 (void)   {
     if(ret == -1)
         return 0;
     ret = Unified2Alert(&tv, &p, data, &pq);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
     ret = Unified2AlertThreadDeinit(&tv, data);
     if(ret == -1)
@@ -914,10 +916,10 @@ static int Unified2Test05 (void)   {
     if(ret == -1)
         return 0;
     ret = Unified2Alert(&tv, &p, data, &pq);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
     ret = Unified2AlertThreadDeinit(&tv, data);
-    if(ret == -1)
+    if(ret == TM_ECODE_FAILED)
         return 0;
 
     if(LogFileFreeCtx(lf)==0)

src/detect-engine-mpm.h

@@ -1,6 +1,8 @@
 #ifndef __DETECT_MPM_H__
 #define __DETECT_MPM_H__
 
+#include "tm-modules.h"
+
 /* XXX remove once */
 MpmCtx mpm_ctx[1];
 
@@ -14,8 +16,8 @@ void DetectEngineThreadCtxInfo(ThreadVars *, DetectEngineThreadCtx *);
 void PatternMatchDestroy(MpmCtx *);
 void PatternMatchDestroyGroup(SigGroupHead *);
 
-int DetectEngineThreadCtxInit(ThreadVars *, void *, void **);
-int DetectEngineThreadCtxDeinit(ThreadVars *, void *);
+TmEcode DetectEngineThreadCtxInit(ThreadVars *, void *, void **);
+TmEcode DetectEngineThreadCtxDeinit(ThreadVars *, void *);
 
 void SigGroupHeadSetMpmMaxlen(DetectEngineCtx *, SigGroupHead *);
 

src/detect-engine.c

@@ -21,6 +21,7 @@
 #include "util-hash.h"
 
 #include "util-var-name.h"
+#include "tm-modules.h"
 
 DetectEngineCtx *DetectEngineCtxInit(void) {
     DetectEngineCtx *de_ctx;
@@ -76,14 +77,14 @@ void DetectEngineResetMaxSigId(DetectEngineCtx *de_ctx) {
     de_ctx->signum = 0;
 }
 
-int DetectEngineThreadCtxInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode DetectEngineThreadCtxInit(ThreadVars *tv, void *initdata, void **data) {
     DetectEngineCtx *de_ctx = (DetectEngineCtx *)initdata;
     if (de_ctx == NULL)
-        return -1;
+        return TM_ECODE_FAILED;
 
     DetectEngineThreadCtx *det_ctx = malloc(sizeof(DetectEngineThreadCtx));
     if (det_ctx == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(det_ctx, 0, sizeof(DetectEngineThreadCtx));
 
@@ -110,17 +111,17 @@ int DetectEngineThreadCtxInit(ThreadVars *tv, void *initdata, void **data) {
 
     *data = (void *)det_ctx;
     //printf("DetectEngineThreadCtxInit: data %p det_ctx %p\n", *data, det_ctx);
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int DetectEngineThreadCtxDeinit(ThreadVars *tv, void *data) {
+TmEcode DetectEngineThreadCtxDeinit(ThreadVars *tv, void *data) {
     DetectEngineThreadCtx *det_ctx = (DetectEngineThreadCtx *)data;
 
     /** \todo get rid of this static */
     mpm_ctx[0].DestroyThreadCtx(&mpm_ctx[0], &det_ctx->mtc);
     mpm_ctx[0].DestroyThreadCtx(&mpm_ctx[0], &det_ctx->mtcu);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void DetectEngineThreadCtxInfo(ThreadVars *t, DetectEngineThreadCtx *det_ctx) {

src/detect.c

@@ -69,9 +69,9 @@ void DbgPrintSigs(DetectEngineCtx *, SigGroupHead *);
 void DbgPrintSigs2(DetectEngineCtx *, SigGroupHead *);
 
 /* tm module api functions */
-int Detect(ThreadVars *, Packet *, void *, PacketQueue *);
-int DetectThreadInit(ThreadVars *, void *, void **);
-int DetectThreadDeinit(ThreadVars *, void *);
+TmEcode Detect(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DetectThreadInit(ThreadVars *, void *, void **);
+TmEcode DetectThreadDeinit(ThreadVars *, void *);
 
 void TmModuleDetectRegister (void) {
     tmm_modules[TMM_DETECT].name = "Detect";
@@ -517,7 +517,7 @@ int SigMatchSignatures(ThreadVars *th_v, DetectEngineCtx *de_ctx, DetectEngineTh
  *  \retval 1 error
  *  \retval 0 ok
  */
-int Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
 
     /*No need to perform any detection on this packet, if the the given flag is set.*/
     if (p->flags & PKT_NOPACKET_INSPECTION)
@@ -538,19 +538,19 @@ int Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     /* see if the packet matches one or more of the sigs */
     int r = SigMatchSignatures(tv,de_ctx,det_ctx,p);
     if (r >= 0) {
-        return 0;
+        return TM_ECODE_OK;
     }
 
 error:
-    return 1;
+    return TM_ECODE_FAILED;
 }
 
-int DetectThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode DetectThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     return DetectEngineThreadCtxInit(t,initdata,data);
 }
 
-int DetectThreadDeinit(ThreadVars *t, void *data) {
+TmEcode DetectThreadDeinit(ThreadVars *t, void *data) {
     return DetectEngineThreadCtxDeinit(t,data);
 }
 

src/log-httplog.c

@@ -22,11 +22,11 @@
 
 #define DEFAULT_LOG_FILENAME "http.log"
 
-int LogHttplog (ThreadVars *, Packet *, void *, PacketQueue *);
-int LogHttplogIPv4(ThreadVars *, Packet *, void *, PacketQueue *);
-int LogHttplogIPv6(ThreadVars *, Packet *, void *, PacketQueue *);
-int LogHttplogThreadInit(ThreadVars *, void *, void **);
-int LogHttplogThreadDeinit(ThreadVars *, void *);
+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* , char *);
 
@@ -74,7 +74,7 @@ static void CreateTimeString (const struct timeval *ts, char *str, size_t size)
         (uint32_t) ts->tv_usec);
 }
 
-int LogHttplogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode LogHttplogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     LogHttplogThread *aft = (LogHttplogThread *)data;
     int i;
@@ -82,7 +82,7 @@ int LogHttplogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 
     /* XXX add a better check for this */
     if (p->http_uri.cnt == 0)
-        return 0;
+        return TM_ECODE_OK;
 
     PktVar *pv_hn = PktVarGet(p, "http_host");
     PktVar *pv_ua = PktVarGet(p, "http_ua");
@@ -114,10 +114,10 @@ int LogHttplogIPv4(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     mutex_unlock(&aft->file_ctx->fp_mutex);
 
     aft->uri_cnt += p->http_uri.cnt;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int LogHttplogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode LogHttplogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     LogHttplogThread *aft = (LogHttplogThread *)data;
     int i;
@@ -125,7 +125,7 @@ int LogHttplogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 
     /* XXX add a better check for this */
     if (p->http_uri.cnt == 0)
-        return 0;
+        return TM_ECODE_OK;
 
     PktVar *pv_hn = PktVarGet(p, "http_host");
     PktVar *pv_ua = PktVarGet(p, "http_ua");
@@ -157,13 +157,13 @@ int LogHttplogIPv6(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     mutex_unlock(&aft->file_ctx->fp_mutex);
 
     aft->uri_cnt += p->http_uri.cnt;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int 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 0;
+        return TM_ECODE_OK;
 
     if (PKT_IS_IPV4(p)) {
         return LogHttplogIPv4(tv, p, data, pq);
@@ -171,41 +171,41 @@ int LogHttplog (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
         return LogHttplogIPv6(tv, p, data, pq);
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int LogHttplogThreadInit(ThreadVars *t, void *initdata, void **data)
+TmEcode LogHttplogThreadInit(ThreadVars *t, void *initdata, void **data)
 {
     LogHttplogThread *aft = malloc(sizeof(LogHttplogThread));
     if (aft == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(aft, 0, sizeof(LogHttplogThread));
 
     if(initdata == NULL)
     {
         printf("Error getting context for the file\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     /** Use the Ouptut Context (file pointer and mutex) */
     aft->file_ctx=(LogFileCtx*) initdata;
 
     *data = (void *)aft;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int LogHttplogThreadDeinit(ThreadVars *t, void *data)
+TmEcode LogHttplogThreadDeinit(ThreadVars *t, void *data)
 {
     LogHttplogThread *aft = (LogHttplogThread *)data;
     if (aft == NULL) {
-        return 0;
+        return TM_ECODE_OK;
     }
 
     /* clear memory */
     memset(aft, 0, sizeof(LogHttplogThread));
 
     free(aft);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void LogHttplogExitPrintStats(ThreadVars *tv, void *data) {

src/respond-reject.c

@@ -37,34 +37,42 @@ void TmModuleRespondRejectRegister (void) {
     tmm_modules[TMM_RESPONDREJECT].RegisterTests = NULL;
 }
 
-int RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
 
+    int ret = 0;
     /* ACTION_REJECT defaults to rejecting the SRC */
     if (p->action != ACTION_REJECT && p->action != ACTION_REJECT_DST &&
         p->action != ACTION_REJECT_BOTH) {
-        return 0;
+        return TM_ECODE_OK;
     }
 
     if (PKT_IS_IPV4(p)) {
         if (PKT_IS_TCP(p)) {
-            return RejectSendIPv4TCP(tv, p, data);
+            ret = RejectSendIPv4TCP(tv, p, data);
+            goto end;
         } else if(PKT_IS_UDP(p)) {
-            return RejectSendIPv4ICMP(tv, p, data);
+            ret = RejectSendIPv4ICMP(tv, p, data);
+            goto end;
         } else {
-            return 0;
+            return TM_ECODE_OK;
         }
     } else if (PKT_IS_IPV6(p)) {
         if (PKT_IS_TCP(p)) {
-            return RejectSendIPv6TCP(tv, p, data);
+            ret = RejectSendIPv6TCP(tv, p, data);
         } else if(PKT_IS_UDP(p)){
-            return RejectSendIPv6ICMP(tv, p, data);
+            ret = RejectSendIPv6ICMP(tv, p, data);
         } else {
-            return 0;
+            return TM_ECODE_OK;
         }
     } else {
         /* we're only supporting IPv4 and IPv6 */
-        return 0;
+        return TM_ECODE_OK;
     }
+end:
+    if (ret)
+        return TM_ECODE_FAILED;
+    else
+        return TM_ECODE_OK;
 }
 
 int RejectSendIPv4TCP(ThreadVars *tv, Packet *p, void *data) {

src/respond-reject.h

@@ -7,6 +7,6 @@
 #define REJECT_DIR_DST 1
 
 void TmModuleRespondRejectRegister (void);
-int RespondRejectFunc(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode RespondRejectFunc(ThreadVars *, Packet *, void *, PacketQueue *);
 
 #endif /* __RESPOND_REJECT_H__ */

src/source-nfq.c

@@ -24,7 +24,7 @@
  *
  */
 
-int NoNFQSupportExit(ThreadVars *, void *, void **);
+TmEcode NoNFQSupportExit(ThreadVars *, void *, void **);
 
 void TmModuleReceiveNFQRegister (void) {
     tmm_modules[TMM_RECEIVENFQ].name = "ReceiveNFQ";
@@ -53,11 +53,11 @@ void TmModuleDecodeNFQRegister (void) {
     tmm_modules[TMM_DECODENFQ].RegisterTests = NULL;
 }
 
-int NoNFQSupportExit(ThreadVars *tv, void *initdata, void **data)
+TmEcode NoNFQSupportExit(ThreadVars *tv, void *initdata, void **data)
 {
     printf("Error creating thread %s: you do not have support for nfqueue "
            "enabled please recompile with --enable-nfqueue\n", tv->name);
-    exit(1);
+    exit(TM_ECODE_FAILED);
 }
 
 #else /* implied we do have NFQ support */
@@ -70,17 +70,17 @@ static uint16_t receive_queue_num = 0;
 static uint16_t verdict_queue_num = 0;
 static pthread_mutex_t nfq_init_lock;
 
-int ReceiveNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
-int ReceiveNFQThreadInit(ThreadVars *, void *, void **);
+TmEcode ReceiveNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode ReceiveNFQThreadInit(ThreadVars *, void *, void **);
 void ReceiveNFQThreadExitStats(ThreadVars *, void *);
 
-int VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
-int VerdictNFQThreadInit(ThreadVars *, void *, void **);
+TmEcode VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode VerdictNFQThreadInit(ThreadVars *, void *, void **);
 void VerdictNFQThreadExitStats(ThreadVars *, void *);
-int VerdictNFQThreadDeinit(ThreadVars *, void *);
+TmEcode VerdictNFQThreadDeinit(ThreadVars *, void *);
 
-int DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
-int DecodeNFQThreadInit(ThreadVars *, void *, void **);
+TmEcode DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodeNFQThreadInit(ThreadVars *, void *, void **);
 
 void TmModuleReceiveNFQRegister (void) {
     /* XXX create a general NFQ setup function */
@@ -173,7 +173,7 @@ static int NFQCallBack(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg,
     return 0;
 }
 
-int NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxlen)
+TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxlen)
 {
     struct timeval tv;
 
@@ -183,7 +183,7 @@ int NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxle
     nfq_t->h = nfq_open();
     if (!nfq_t->h) {
         printf("error during nfq_open()\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     if (nfq_g.unbind == 0)
@@ -205,11 +205,11 @@ int NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxle
 
         if (nfq_bind_pf(nfq_t->h, AF_INET) < 0) {
             printf("error during nfq_bind_pf()\n");
-            return -1;
+            return TM_ECODE_FAILED;
         }
         if (nfq_bind_pf(nfq_t->h, AF_INET6) < 0) {
             printf("error during nfq_bind_pf()\n");
-            return -1;
+            return TM_ECODE_FAILED;
         }
     }
 
@@ -221,7 +221,7 @@ int NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxle
     if (nfq_t->qh == NULL)
     {
         printf("error during nfq_create_queue()\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     printf("NFQInitThread: setting copy_packet mode\n");
@@ -230,7 +230,7 @@ int NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxle
     //if (nfq_set_mode(nfq_t->qh, NFQNL_COPY_PACKET, 0x05DC) < 0) {
     if (nfq_set_mode(nfq_t->qh, NFQNL_COPY_PACKET, 0xFFFF) < 0) {
         printf("can't set packet_copy mode\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     /* XXX detect this at configure time & make it an option */
@@ -260,10 +260,10 @@ int NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_maxle
     }
 
     //printf("NFQInitThread: nfq_t->h %p, nfq_t->nh %p, nfq_t->qh %p, nfq_t->fd %" PRId32 "\n", nfq_t->h, nfq_t->nh, nfq_t->qh, nfq_t->fd);
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int ReceiveNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode ReceiveNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
     mutex_lock(&nfq_init_lock);
     printf("ReceiveNFQThreadInit: starting... will bind to queuenum %" PRIu32 "\n", receive_queue_num);
 
@@ -282,16 +282,16 @@ int ReceiveNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
         printf("NFQInitThread failed\n");
         //return -1;
         mutex_unlock(&nfq_init_lock);
-        exit(1);
+        exit(TM_ECODE_FAILED);
     }
 
     *data = (void *)ntv;
     receive_queue_num++;
     mutex_unlock(&nfq_init_lock);
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int VerdictNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode VerdictNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
     mutex_lock(&nfq_init_lock);
     printf("VerdictNFQThreadInit: starting... will bind to queuenum %" PRIu32 "\n", verdict_queue_num);
 
@@ -302,16 +302,16 @@ int VerdictNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
     verdict_queue_num++;
 
     mutex_unlock(&nfq_init_lock);
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int VerdictNFQThreadDeinit(ThreadVars *tv, void *data) {
+TmEcode VerdictNFQThreadDeinit(ThreadVars *tv, void *data) {
     NFQThreadVars *ntv = (NFQThreadVars *)data;
 
     printf("VerdictNFQThreadDeinit: starting... will close queuenum %" PRIu32 "\n", ntv->queue_num);
     nfq_destroy_queue(ntv->qh);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void NFQRecvPkt(NFQThreadVars *t) {
@@ -347,7 +347,7 @@ void NFQRecvPkt(NFQThreadVars *t) {
     }
 }
 
-int ReceiveNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode ReceiveNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     NFQThreadVars *ntv = (NFQThreadVars *)data;
 
     //printf("%p receiving on queue %" PRIu32 "\n", ntv, ntv->queue_num);
@@ -362,7 +362,7 @@ int ReceiveNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
         pthread_cond_wait(&cond_pending, &mutex_pending);
     }
     mutex_unlock(&mutex_pending);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void ReceiveNFQThreadExitStats(ThreadVars *tv, void *data) {
@@ -413,7 +413,7 @@ void NFQSetVerdict(NFQThreadVars *t, Packet *p) {
         printf("NFQSetVerdict: nfq_set_verdict of %p failed %" PRId32 "\n", p, ret);
 }
 
-int VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     NFQThreadVars *ntv = (NFQThreadVars *)data;
 
     /* if this is a tunnel packet we check if we are ready to verdict
@@ -443,7 +443,7 @@ int VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
         /* no tunnel, verdict normally */
         NFQSetVerdict(ntv, p);
     }
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /*
@@ -451,7 +451,7 @@ int VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
  *
  *
  */
-int DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     IPV4Hdr *ip4h = (IPV4Hdr *)p->pkt;
     IPV6Hdr *ip6h = (IPV6Hdr *)p->pkt;
@@ -482,16 +482,16 @@ int DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 #endif
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int DecodeNFQThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode DecodeNFQThreadInit(ThreadVars *tv, void *initdata, void **data)
 {
     DecodeThreadVars *dtv = NULL;
 
     if ( (dtv = malloc(sizeof(DecodeThreadVars))) == NULL) {
         printf("Error Allocating memory\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(dtv, 0, sizeof(DecodeThreadVars));
 
@@ -520,7 +520,7 @@ int DecodeNFQThreadInit(ThreadVars *tv, void *initdata, void **data)
 
     *data = (void *)dtv;
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
 #endif /* NFQ */

src/source-pcap-file.c

@@ -43,13 +43,13 @@ typedef struct PcapFileThreadVars_
 
 static PcapFileGlobalVars pcap_g = { NULL, NULL, };
 
-int ReceivePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
-int ReceivePcapFileThreadInit(ThreadVars *, void *, void **);
+TmEcode ReceivePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode ReceivePcapFileThreadInit(ThreadVars *, void *, void **);
 void ReceivePcapFileThreadExitStats(ThreadVars *, void *);
-int ReceivePcapFileThreadDeinit(ThreadVars *, void *);
+TmEcode ReceivePcapFileThreadDeinit(ThreadVars *, void *);
 
-int DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
-int DecodePcapFileThreadInit(ThreadVars *, void *, void **);
+TmEcode DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodePcapFileThreadInit(ThreadVars *, void *, void **);
 
 void TmModuleReceivePcapFileRegister (void) {
     tmm_modules[TMM_RECEIVEPCAPFILE].name = "ReceivePcapFile";
@@ -95,7 +95,7 @@ void PcapFileCallback(char *user, struct pcap_pkthdr *h, u_char *pkt) {
     //printf("PcapFileCallback: p->pktlen: %" PRIu32 " (pkt %02x, p->pkt %02x)\n", p->pktlen, *pkt, *p->pkt);
 }
 
-int ReceivePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode ReceivePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     PcapFileThreadVars *ptv = (PcapFileThreadVars *)data;
 
     ptv->in_p = p;
@@ -105,21 +105,21 @@ int ReceivePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     if (r <= 0) {
         printf("ReceivePcap: code %" PRId32 " error %s\n", r, pcap_geterr(pcap_g.pcap_handle));
         EngineStop();
-        return 1;
+        return TM_ECODE_FAILED;
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int ReceivePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode ReceivePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data) {
     if (initdata == NULL) {
         printf("ReceivePcapFileThreadInit error: initdata == NULL\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     PcapFileThreadVars *ptv = malloc(sizeof(PcapFileThreadVars));
     if (ptv == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(ptv, 0, sizeof(PcapFileThreadVars));
 
@@ -149,7 +149,7 @@ int ReceivePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data) {
 
     ptv->tv = tv;
     *data = (void *)ptv;
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void ReceivePcapFileThreadExitStats(ThreadVars *tv, void *data) {
@@ -159,11 +159,11 @@ void ReceivePcapFileThreadExitStats(ThreadVars *tv, void *data) {
     return;
 }
 
-int ReceivePcapFileThreadDeinit(ThreadVars *tv, void *data) {
-    return 0;
+TmEcode ReceivePcapFileThreadDeinit(ThreadVars *tv, void *data) {
+    return TM_ECODE_OK;
 }
 
-int DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 
@@ -176,16 +176,16 @@ int DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
     /* call the decoder */
     pcap_g.Decoder(tv, dtv, p, p->pkt, p->pktlen, pq);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int DecodePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode DecodePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data)
 {
     DecodeThreadVars *dtv = NULL;
 
     if ( (dtv = malloc(sizeof(DecodeThreadVars))) == NULL) {
         printf("Error Allocating memory\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(dtv, 0, sizeof(DecodeThreadVars));
 
@@ -212,7 +212,7 @@ int DecodePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data)
     PerfAddToClubbedTMTable(tv->name, &tv->pctx);
 
     *data = (void *)dtv;
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /* eof */

src/source-pcap.c

@@ -37,13 +37,13 @@ typedef struct PcapThreadVars_
     ThreadVars *tv;
 } PcapThreadVars;
 
-int ReceivePcap(ThreadVars *, Packet *, void *, PacketQueue *);
-int ReceivePcapThreadInit(ThreadVars *, void *, void **);
+TmEcode ReceivePcap(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode ReceivePcapThreadInit(ThreadVars *, void *, void **);
 void ReceivePcapThreadExitStats(ThreadVars *, void *);
-int ReceivePcapThreadDeinit(ThreadVars *, void *);
+TmEcode ReceivePcapThreadDeinit(ThreadVars *, void *);
 
-int DecodePcapThreadInit(ThreadVars *, void *, void **);
-int DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodePcapThreadInit(ThreadVars *, void *, void **);
+TmEcode DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *);
 
 /**
  * \brief Registration Function for RecievePcap.
@@ -118,7 +118,7 @@ void PcapCallback(char *user, struct pcap_pkthdr *h, u_char *pkt) {
  * \param data pointer that gets cast into PcapThreadVars for ptv
  * \param pq pointer to the PacketQueue (not used here but part of the api)
  */
-int ReceivePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode ReceivePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     PcapThreadVars *ptv = (PcapThreadVars *)data;
 
     /// Just read one packet at a time for now.
@@ -134,11 +134,11 @@ int ReceivePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
 
         if (TmThreadsCheckFlag(tv, THV_KILL) || TmThreadsCheckFlag(tv, THV_PAUSE)) {
             SCLogInfo("pcap packet reading interrupted");
-            return 0;
+            return TM_ECODE_OK;
         }
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -157,15 +157,15 @@ int ReceivePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
  * \todo Create a general pcap setup function.
  */
 #if LIBPCAP_VERSION_MAJOR == 1
-int ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) {
     if (initdata == NULL) {
         printf("ReceivePcapThreadInit error: initdata == NULL\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     PcapThreadVars *ptv = malloc(sizeof(PcapThreadVars));
     if (ptv == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(ptv, 0, sizeof(PcapThreadVars));
 
@@ -214,18 +214,18 @@ int ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) {
     ptv->datalink = pcap_datalink(ptv->pcap_handle);
 
     *data = (void *)ptv;
-    return 0;
+    return TM_ECODE_OK;
 }
 #else /* implied LIBPCAP_VERSION_MAJOR == 0 */
-int ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) {
     if (initdata == NULL) {
         printf("ReceivePcapThreadInit error: initdata == NULL\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     PcapThreadVars *ptv = malloc(sizeof(PcapThreadVars));
     if (ptv == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(ptv, 0, sizeof(PcapThreadVars));
 
@@ -244,7 +244,7 @@ int ReceivePcapThreadInit(ThreadVars *tv, void *initdata, void **data) {
     ptv->datalink = pcap_datalink(ptv->pcap_handle);
 
     *data = (void *)ptv;
-    return 0;
+    return TM_ECODE_OK;
 }
 #endif /* LIBPCAP_VERSION_MAJOR */
 
@@ -265,11 +265,11 @@ void ReceivePcapThreadExitStats(ThreadVars *tv, void *data) {
  * \param tv pointer to ThreadVars
  * \param data pointer that gets cast into PcapThreadVars for ptv
  */
-int ReceivePcapThreadDeinit(ThreadVars *tv, void *data) {
+TmEcode ReceivePcapThreadDeinit(ThreadVars *tv, void *data) {
     PcapThreadVars *ptv = (PcapThreadVars *)data;
 
     pcap_close(ptv->pcap_handle);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -283,7 +283,7 @@ int ReceivePcapThreadDeinit(ThreadVars *tv, void *data) {
  * \param data pointer that gets cast into PcapThreadVars for ptv
  * \param pq pointer to the current PacketQueue
  */
-int DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 
@@ -309,16 +309,16 @@ int DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
             break;
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int DecodePcapThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode DecodePcapThreadInit(ThreadVars *tv, void *initdata, void **data)
 {
     DecodeThreadVars *dtv = NULL;
 
     if ( (dtv = malloc(sizeof(DecodeThreadVars))) == NULL) {
         printf("Error Allocating memory\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(dtv, 0, sizeof(DecodeThreadVars));
 
@@ -345,7 +345,7 @@ int DecodePcapThreadInit(ThreadVars *tv, void *initdata, void **data)
     PerfAddToClubbedTMTable(tv->name, &tv->pctx);
 
     *data = (void *)dtv;
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /* eof */

src/source-pfring.c

@@ -16,18 +16,18 @@
 #include "source-pfring.h"
 
 
-int ReceivePfring(ThreadVars *, Packet *, void *, PacketQueue *);
-int ReceivePfringThreadInit(ThreadVars *, void *, void **);
+TmEcode ReceivePfring(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode ReceivePfringThreadInit(ThreadVars *, void *, void **);
 void ReceivePfringThreadExitStats(ThreadVars *, void *);
-int ReceivePfringThreadDeinit(ThreadVars *, void *);
+TmEcode ReceivePfringThreadDeinit(ThreadVars *, void *);
 
-int DecodePfringThreadInit(ThreadVars *, void *, void **);
-int DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodePfringThreadInit(ThreadVars *, void *, void **);
+TmEcode DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *);
 
 #ifndef HAVE_PFRING
 
 /*Handle cases where we don't have PF_RING support built-in*/
-int NoPfringSupportExit(ThreadVars *, void *, void **);
+TmEcode NoPfringSupportExit(ThreadVars *, void *, void **);
 
 void TmModuleReceivePfringRegister (void) {
     tmm_modules[TMM_RECEIVEPFRING].name = "ReceivePfring";
@@ -53,7 +53,7 @@ void TmModuleDecodePfringRegister (void) {
  * \param initdata pointer to the interface passed from the user
  * \param data pointer gets populated with PfringThreadVars
  */
-int NoPfringSupportExit(ThreadVars *tv, void *initdata, void **data)
+TmEcode NoPfringSupportExit(ThreadVars *tv, void *initdata, void **data)
 {
     printf("Error creating thread %s: you do not have support for pfring "
            "enabled please recompile with --enable-pfring\n", tv->name);
@@ -151,7 +151,7 @@ void PfringProcessPacket(void *user, struct pfring_pkthdr *h, u_char *pkt, Packe
  * \retval 0 on success
  * \retval -1 on failure
  */
-int ReceivePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
+TmEcode ReceivePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
     PfringThreadVars *ptv = (PfringThreadVars *)data;
 
     struct pfring_pkthdr hdr;
@@ -160,7 +160,7 @@ int ReceivePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
 
     if (TmThreadsCheckFlag(tv, THV_KILL) || TmThreadsCheckFlag(tv, THV_PAUSE)) {
         printf("ReceivePfring: interrupted.\n");
-        return 0;
+        return TM_ECODE_OK;
     }
 
     /* Depending on what compile time options are used for pfring we either return 0 or -1 on error and always 1 for success */
@@ -171,10 +171,10 @@ int ReceivePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
         PfringProcessPacket(ptv, &hdr, buffer,p);
     }else{
         printf("RecievePfring: pfring_recv error  %" PRId32 "\n", r);
-        return 1;
+        return TM_ECODE_FAILED;
     }
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -191,21 +191,21 @@ int ReceivePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq) {
  * \retval 0 on success
  * \retval -1 on error
  */
-int ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data) {
+TmEcode ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data) {
     int rc;
     u_int32_t version;
     char *tmpclusterid;
 
     PfringThreadVars *ptv = malloc(sizeof(PfringThreadVars));
     if (ptv == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(ptv, 0, sizeof(PfringThreadVars));
 
     ptv->tv = tv;
     if (ConfGet("pfring.clusterid", &tmpclusterid) != 1){
         printf("could not get pfring.clusterid\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }else{
         ptv->cluster_id = (uint8_t)atoi(tmpclusterid);
         printf("ReceivePfringThreadInit: going to use clusterid %" PRId32 "\n", ptv->cluster_id);
@@ -213,7 +213,7 @@ int ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data) {
 
     if (ConfGet("pfring.interface", &ptv->interface) != 1){
          printf("ReceivePfringThreadInit: Could not get pfring.interface\n");
-         return -1;
+         return TM_ECODE_FAILED;
     }else{
          printf("ReceivePfringThreadInit: going to use interface %s\n",ptv->interface);
     }
@@ -221,7 +221,7 @@ int ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data) {
     ptv->pd = pfring_open(ptv->interface, LIBPFRING_PROMISC, LIBPFRING_SNAPLEN, LIBPFRING_REENTRANT);
     if(ptv->pd == NULL) {
         printf("pfring_open error\n");
-        return -1;
+        return TM_ECODE_FAILED;
     } else {
         pfring_set_application_name(ptv->pd, PROG_NAME);
         pfring_version(ptv->pd, &version);
@@ -235,11 +235,11 @@ int ReceivePfringThreadInit(ThreadVars *tv, void *initdata, void **data) {
     rc = pfring_set_cluster(ptv->pd, ptv->cluster_id);
     if(rc != 0){
         printf("pfring_set_cluster returned %d\n", rc);
-        return -1;
+        return TM_ECODE_FAILED;
     }
 
     *data = (void *)ptv;
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -260,11 +260,11 @@ void ReceivePfringThreadExitStats(ThreadVars *tv, void *data) {
  * \param data pointer that gets cast into PfringThreadVars for ptvi
  * \retval 0 is always returned
  */
-int ReceivePfringThreadDeinit(ThreadVars *tv, void *data) {
+TmEcode ReceivePfringThreadDeinit(ThreadVars *tv, void *data) {
     PfringThreadVars *ptv = (PfringThreadVars *)data;
     pfring_remove_from_cluster(ptv->pd);
     pfring_close(ptv->pd);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -280,7 +280,7 @@ int ReceivePfringThreadDeinit(ThreadVars *tv, void *data) {
  * \todo Verify that PF_RING only deals with ethernet traffic
  * \retval 0 is always returned
  */
-int DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 
@@ -292,7 +292,7 @@ int DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 
     DecodeEthernet(tv, dtv, p,p->pkt, p->pktlen, pq);
 
-    return 0;
+    return TM_ECODE_OK;
 }
 
 /**
@@ -304,13 +304,13 @@ int DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
  * \retval 0 is returned on success
  * \retval -1 is returned on error
  */
-int DecodePfringThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode DecodePfringThreadInit(ThreadVars *tv, void *initdata, void **data)
 {
     DecodeThreadVars *dtv = NULL;
 
     if ( (dtv = malloc(sizeof(DecodeThreadVars))) == NULL) {
         printf("Error Allocating memory\n");
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(dtv, 0, sizeof(DecodeThreadVars));
 
@@ -337,7 +337,7 @@ int DecodePfringThreadInit(ThreadVars *tv, void *initdata, void **data)
     PerfAddToClubbedTMTable(tv->name, &tv->pctx);
 
     *data = (void *)dtv;
-    return 0;
+    return TM_ECODE_OK;
 }
 #endif /* HAVE_PFRING */
 /* eof */

src/stream-tcp.c

@@ -34,9 +34,9 @@ typedef struct StreamTcpThread_ {
     TcpReassemblyThreadCtx *ra_ctx;
 } StreamTcpThread;
 
-int StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *);
-int StreamTcpThreadInit(ThreadVars *, void *, void **);
-int StreamTcpThreadDeinit(ThreadVars *, void *);
+TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode StreamTcpThreadInit(ThreadVars *, void *, void **);
+TmEcode StreamTcpThreadDeinit(ThreadVars *, void *);
 void StreamTcpExitPrintStats(ThreadVars *, void *);
 static int ValidReset(TcpSession * , Packet *);
 static int StreamTcpHandleFin(StreamTcpThread *, TcpSession *, Packet *);
@@ -1463,29 +1463,33 @@ static int StreamTcpPacket (ThreadVars *tv, Packet *p, StreamTcpThread *stt) {
     return 0;
 }
 
-int StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     StreamTcpThread *stt = (StreamTcpThread *)data;
+    TmEcode ret = TM_ECODE_OK;
 
     if (!(PKT_IS_TCP(p)))
-        return 0;
+        return TM_ECODE_OK;
 
     if (p->flow == NULL)
-        return 0;
+        return TM_ECODE_OK;
 
     mutex_lock(&p->flow->m);
-    StreamTcpPacket(tv, p, stt);
+    ret = StreamTcpPacket(tv, p, stt);
     mutex_unlock(&p->flow->m);
 
+    if (ret)
+        return TM_ECODE_FAILED;
+
     stt->pkts++;
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
 {
     StreamTcpThread *stt = malloc(sizeof(StreamTcpThread));
     if (stt == NULL) {
-        return -1;
+        return TM_ECODE_FAILED;
     }
     memset(stt, 0, sizeof(StreamTcpThread));
 
@@ -1498,17 +1502,17 @@ int StreamTcpThreadInit(ThreadVars *tv, void *initdata, void **data)
     /* init reassembly ctx */
     stt->ra_ctx = StreamTcpReassembleInitThreadCtx();
     if (stt->ra_ctx == NULL)
-        return -1;
+        return TM_ECODE_FAILED;
 
     SCLogDebug("StreamTcp thread specific ctx online at %p, reassembly ctx %p", stt, stt->ra_ctx);
-    return 0;
+    return TM_ECODE_OK;
 }
 
-int StreamTcpThreadDeinit(ThreadVars *tv, void *data)
+TmEcode StreamTcpThreadDeinit(ThreadVars *tv, void *data)
 {
     StreamTcpThread *stt = (StreamTcpThread *)data;
     if (stt == NULL) {
-        return 0;
+        return TM_ECODE_OK;
     }
 
     /* XXX */
@@ -1520,7 +1524,7 @@ int StreamTcpThreadDeinit(ThreadVars *tv, void *data)
     memset(stt, 0, sizeof(StreamTcpThread));
 
     free(stt);
-    return 0;
+    return TM_ECODE_OK;
 }
 
 void StreamTcpExitPrintStats(ThreadVars *tv, void *data) {

src/tm-modules.h

@@ -3,16 +3,22 @@
 
 #include "threadvars.h"
 
+/*Error codes for the thread modules*/
+typedef enum {
+    TM_ECODE_OK = 0,    /**< Thread module exits OK*/
+    TM_ECODE_FAILED,    /**< Thread module exits due to failure*/
+}TmEcode;
+
 typedef struct TmModule_ {
     char *name;
 
     /** thread handling */
-    int (*ThreadInit)(ThreadVars *, void *, void **);
+    TmEcode (*ThreadInit)(ThreadVars *, void *, void **);
     void (*ThreadExitPrintStats)(ThreadVars *, void *);
-    int (*ThreadDeinit)(ThreadVars *, void *);
+    TmEcode (*ThreadDeinit)(ThreadVars *, void *);
 
     /** the packet processing function */
-    int (*Func)(ThreadVars *, Packet *, void *, PacketQueue *);
+    TmEcode (*Func)(ThreadVars *, Packet *, void *, PacketQueue *);
 
     void (*RegisterTests)(void);
 } TmModule;
@@ -45,12 +51,6 @@ enum {
 
 TmModule tmm_modules[TMM_SIZE];
 
-/*Error codes for the thread modules*/
-typedef enum {
-    TM_ECODE_OK = 0,    /**< Thread module exits OK*/
-    TM_ECODE_FAILED,    /**< Thread module exits due to failure*/
-}TmEcode;
-
 /** Global structure for Output Context */
 typedef struct LogFileCtx_ {
     FILE *fp;

src/tm-threads.c

@@ -30,11 +30,11 @@ uint8_t tv_aof = THV_RESTART_THREAD;
 
 typedef struct TmSlot_ {
     /* function pointers */
-    int (*SlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *);
+    TmEcode (*SlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *);
 
-    int (*SlotThreadInit)(ThreadVars *, void *, void **);
+    TmEcode (*SlotThreadInit)(ThreadVars *, void *, void **);
     void (*SlotThreadExitPrintStats)(ThreadVars *, void *);
-    int (*SlotThreadDeinit)(ThreadVars *, void *);
+    TmEcode (*SlotThreadDeinit)(ThreadVars *, void *);
 
     /* data storage */
     void *slot_initdata;
@@ -85,14 +85,14 @@ void *TmThreadsSlot1NoIn(void *td) {
     Tm1Slot *s = (Tm1Slot *)tv->tm_slots;
     Packet *p = NULL;
     char run = 1;
-    int r = 0;
+    TmEcode r = TM_ECODE_OK;
 
     if (tv->set_cpu_affinity == 1)
         SetCPUAffinity(tv->cpu_affinity);
 
     if (s->s.SlotThreadInit != NULL) {
         r = s->s.SlotThreadInit(tv, s->s.slot_initdata, &s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             EngineKill();
 
             TmThreadsSetFlag(tv, THV_CLOSED);
@@ -109,7 +109,7 @@ void *TmThreadsSlot1NoIn(void *td) {
         r = s->s.SlotFunc(tv, p, s->s.slot_data, &s->s.slot_pq);
 
         /* handle error */
-        if (r == 1) {
+        if (r == TM_ECODE_FAILED) {
             TmqhReleasePacketsToPacketPool(&s->s.slot_pq);
             TmqhOutputPacketpool(tv, p);
             TmThreadsSetFlag(tv, THV_FAILED);
@@ -135,7 +135,7 @@ void *TmThreadsSlot1NoIn(void *td) {
 
     if (s->s.SlotThreadDeinit != NULL) {
         r = s->s.SlotThreadDeinit(tv, s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             TmThreadsSetFlag(tv, THV_CLOSED);
             pthread_exit((void *) -1);
         }
@@ -150,14 +150,14 @@ void *TmThreadsSlot1NoOut(void *td) {
     Tm1Slot *s = (Tm1Slot *)tv->tm_slots;
     Packet *p = NULL;
     char run = 1;
-    int r = 0;
+    TmEcode r = TM_ECODE_OK;
 
     if (tv->set_cpu_affinity == 1)
         SetCPUAffinity(tv->cpu_affinity);
 
     if (s->s.SlotThreadInit != NULL) {
         r = s->s.SlotThreadInit(tv, s->s.slot_initdata, &s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             EngineKill();
 
             TmThreadsSetFlag(tv, THV_CLOSED);
@@ -176,7 +176,7 @@ void *TmThreadsSlot1NoOut(void *td) {
         r = s->s.SlotFunc(tv, p, s->s.slot_data, /* no outqh no pq */NULL);
 
         /* handle error */
-        if (r == 1) {
+        if (r == TM_ECODE_FAILED) {
             TmqhOutputPacketpool(tv, p);
             TmThreadsSetFlag(tv, THV_FAILED);
             break;
@@ -194,7 +194,7 @@ void *TmThreadsSlot1NoOut(void *td) {
 
     if (s->s.SlotThreadDeinit != NULL) {
         r = s->s.SlotThreadDeinit(tv, s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             TmThreadsSetFlag(tv, THV_CLOSED);
             pthread_exit((void *) -1);
         }
@@ -208,7 +208,7 @@ void *TmThreadsSlot1NoInOut(void *td) {
     ThreadVars *tv = (ThreadVars *)td;
     Tm1Slot *s = (Tm1Slot *)tv->tm_slots;
     char run = 1;
-    int r = 0;
+    TmEcode r = TM_ECODE_OK;
 
     if (tv->set_cpu_affinity == 1)
         SetCPUAffinity(tv->cpu_affinity);
@@ -217,7 +217,7 @@ void *TmThreadsSlot1NoInOut(void *td) {
 
     if (s->s.SlotThreadInit != NULL) {
         r = s->s.SlotThreadInit(tv, s->s.slot_initdata, &s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             EngineKill();
 
             TmThreadsSetFlag(tv, THV_CLOSED);
@@ -234,7 +234,7 @@ void *TmThreadsSlot1NoInOut(void *td) {
         //printf("%s: TmThreadsSlot1NoInNoOut: r %" PRId32 "\n", tv->name, r);
 
         /* handle error */
-        if (r == 1) {
+        if (r == TM_ECODE_FAILED) {
             TmThreadsSetFlag(tv, THV_FAILED);
             break;
         }
@@ -252,7 +252,7 @@ void *TmThreadsSlot1NoInOut(void *td) {
 
     if (s->s.SlotThreadDeinit != NULL) {
         r = s->s.SlotThreadDeinit(tv, s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             TmThreadsSetFlag(tv, THV_CLOSED);
             pthread_exit((void *) -1);
         }
@@ -268,7 +268,7 @@ void *TmThreadsSlot1(void *td) {
     Tm1Slot *s = (Tm1Slot *)tv->tm_slots;
     Packet *p = NULL;
     char run = 1;
-    int r = 0;
+    TmEcode r = TM_ECODE_OK;
 
     if (tv->set_cpu_affinity == 1)
         SetCPUAffinity(tv->cpu_affinity);
@@ -277,7 +277,7 @@ void *TmThreadsSlot1(void *td) {
 
     if (s->s.SlotThreadInit != NULL) {
         r = s->s.SlotThreadInit(tv, s->s.slot_initdata, &s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             EngineKill();
 
             TmThreadsSetFlag(tv, THV_CLOSED);
@@ -299,7 +299,7 @@ void *TmThreadsSlot1(void *td) {
             r = s->s.SlotFunc(tv, p, s->s.slot_data, &s->s.slot_pq);
 
             /* handle error */
-            if (r == 1) {
+            if (r == TM_ECODE_FAILED) {
                 TmqhReleasePacketsToPacketPool(&s->s.slot_pq);
                 TmqhOutputPacketpool(tv, p);
                 TmThreadsSetFlag(tv, THV_FAILED);
@@ -331,7 +331,7 @@ void *TmThreadsSlot1(void *td) {
 
     if (s->s.SlotThreadDeinit != NULL) {
         r = s->s.SlotThreadDeinit(tv, s->s.slot_data);
-        if (r != 0) {
+        if (r != TM_ECODE_OK) {
             TmThreadsSetFlag(tv, THV_CLOSED);
             pthread_exit((void *) -1);
         }
@@ -344,13 +344,13 @@ void *TmThreadsSlot1(void *td) {
 
 /* separate run function so we can call it recursively */
 static inline TmEcode TmThreadsSlotVarRun (ThreadVars *tv, Packet *p, TmSlot *slot) {
-    int r = 0;
+    TmEcode r = TM_ECODE_OK;
     TmSlot *s = NULL;
 
     for (s = slot; s != NULL; s = s->slot_next) {
         r = s->SlotFunc(tv, p, s->slot_data, &s->slot_pq);
         /* handle error */
-        if (r == 1) {
+        if (r == TM_ECODE_FAILED) {
             //printf("TmThreadsSlotVarRun: s->SlotFunc %p returned 1\n", s->SlotFunc);
             /* Encountered error.  Return packets to packetpool and return */
             TmqhReleasePacketsToPacketPool(&s->slot_pq);
@@ -386,7 +386,7 @@ void *TmThreadsSlotVar(void *td) {
     TmVarSlot *s = (TmVarSlot *)tv->tm_slots;
     Packet *p = NULL;
     char run = 1;
-    int r = 0;
+    TmEcode r = TM_ECODE_OK;
     TmSlot *slot = NULL;
 
     if (tv->set_cpu_affinity == 1)
@@ -397,7 +397,7 @@ void *TmThreadsSlotVar(void *td) {
     for (slot = s->s; slot != NULL; slot = slot->slot_next) {
         if (slot->SlotThreadInit != NULL) {
             r = slot->SlotThreadInit(tv, slot->slot_initdata, &slot->slot_data);
-            if (r != 0) {
+            if (r != TM_ECODE_OK) {
                 EngineKill();
 
                 TmThreadsSetFlag(tv, THV_CLOSED);
@@ -446,7 +446,7 @@ void *TmThreadsSlotVar(void *td) {
 
         if (slot->SlotThreadDeinit != NULL) {
             r = slot->SlotThreadDeinit(tv, slot->slot_data);
-            if (r != 0) {
+            if (r != TM_ECODE_OK) {
                 TmThreadsSetFlag(tv, THV_CLOSED);
                 pthread_exit((void *) -1);
             }
@@ -491,7 +491,7 @@ TmEcode TmThreadSetSlots(ThreadVars *tv, char *name, void *(*fn_p)(void *)) {
             goto error;
 
         tv->tm_func = fn_p;
-        return 0;
+        return TM_ECODE_OK;
     } else {
         printf("Error: Slot \"%s\" not supported\n", name);
         goto error;