threading: remove post_pq argument from 'SlotFunc'

This was not in use anywhere.

diff --git a/src/detect.c b/src/detect.c
index e5a6f271040d74df5db9dfff0b65cb75c0e0a24b..f5a4962b928e50b033e2e1126d76c6ec501e1bb2 100644 (file)
--- a/src/detect.c
+++ b/src/detect.c
@@ -1599,7 +1599,7 @@ static void DetectNoFlow(ThreadVars *tv,
  *  \retval TM_ECODE_FAILED error
  *  \retval TM_ECODE_OK ok
  */
-TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode Detect(ThreadVars *tv, Packet *p, void *data)
 {
     DEBUG_VALIDATE_PACKET(p);
 

diff --git a/src/detect.h b/src/detect.h
index 0a895a8990ed9b058f3fac455ff41e5887cfecd3..81e855adde44485b58a3c7cda830d374d0babce2 100644 (file)
--- a/src/detect.h
+++ b/src/detect.h
@@ -1450,7 +1450,7 @@ SigTableElmt sigmatch_table[DETECT_TBLSIZE];
 /** Remember to add the options in SignatureIsIPOnly() at detect.c otherwise it wont be part of a signature group */
 
 /* detection api */
-TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq);
+TmEcode Detect(ThreadVars *tv, Packet *p, void *data);
 
 SigMatch *SigMatchAlloc(void);
 Signature *SigFindSignatureBySidGid(DetectEngineCtx *, uint32_t, uint32_t);

diff --git a/src/flow-worker.c b/src/flow-worker.c
index 91122f55dfa1e2253720c862a0a0b96ac09f4fc3..3373aa37244480064f6b5fb0b4936e4142471171 100644 (file)
--- a/src/flow-worker.c
+++ b/src/flow-worker.c
@@ -35,6 +35,7 @@
 #include "suricata.h"
 
 #include "decode.h"
+#include "detect.h"
 #include "stream-tcp.h"
 #include "app-layer.h"
 #include "detect-engine.h"
@@ -176,9 +177,6 @@ static TmEcode FlowWorkerThreadDeinit(ThreadVars *tv, void *data)
     return TM_ECODE_OK;
 }
 
-TmEcode Detect(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq);
-TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
-
 static void FlowPruneFiles(Packet *p)
 {
     if (p->flow && p->flow->alstate) {
@@ -191,7 +189,7 @@ static void FlowPruneFiles(Packet *p)
     }
 }
 
-static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *preq, PacketQueue *unused)
+static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *preq)
 {
     FlowWorkerThreadData *fw = data;
     void *detect_thread = SC_ATOMIC_GET(fw->detect_thread);
@@ -242,7 +240,7 @@ static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *pr
         }
 
         FLOWWORKER_PROFILING_START(p, PROFILE_FLOWWORKER_STREAM);
-        StreamTcp(tv, p, fw->stream_thread, &fw->pq, NULL);
+        StreamTcp(tv, p, fw->stream_thread, &fw->pq);
         FLOWWORKER_PROFILING_END(p, PROFILE_FLOWWORKER_STREAM);
 
         if (FlowChangeProto(p->flow)) {
@@ -259,7 +257,7 @@ static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *pr
             //StreamTcp(tv, x, fw->stream_thread, &fw->pq, NULL);
             if (detect_thread != NULL) {
                 FLOWWORKER_PROFILING_START(x, PROFILE_FLOWWORKER_DETECT);
-                Detect(tv, x, detect_thread, NULL, NULL);
+                Detect(tv, x, detect_thread);
                 FLOWWORKER_PROFILING_END(x, PROFILE_FLOWWORKER_DETECT);
             }
 
@@ -286,7 +284,7 @@ static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *pr
 
     if (detect_thread != NULL) {
         FLOWWORKER_PROFILING_START(p, PROFILE_FLOWWORKER_DETECT);
-        Detect(tv, p, detect_thread, NULL, NULL);
+        Detect(tv, p, detect_thread);
         FLOWWORKER_PROFILING_END(p, PROFILE_FLOWWORKER_DETECT);
     }
 

diff --git a/src/respond-reject.c b/src/respond-reject.c
index ea756d7e720e42aa896762033a5fe9bba6eead2c..bd686992c985dc593a63a8d5e6d7288d8e61f21b 100644 (file)
--- a/src/respond-reject.c
+++ b/src/respond-reject.c
@@ -56,7 +56,7 @@ void TmModuleRespondRejectRegister (void)
     tmm_modules[TMM_RESPONDREJECT].cap_flags = 0; /* libnet is not compat with caps */
 }
 
-TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     int ret = 0;
 

diff --git a/src/respond-reject.h b/src/respond-reject.h
index 6a004f4de4f33abe09747625ab45df9f288d440e..353929509b37bd1fa79440e12792965a2035498b 100644 (file)
--- a/src/respond-reject.h
+++ b/src/respond-reject.h
@@ -30,6 +30,6 @@
 #define REJECT_DIR_DST 1
 
 void TmModuleRespondRejectRegister (void);
-TmEcode RespondRejectFunc(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq);
 
 #endif /* __RESPOND_REJECT_H__ */

diff --git a/src/source-af-packet.c b/src/source-af-packet.c
index 712fe521eea253a7eebd109241c4da8f5b7a1ee4..b809ce304765d49127e4bff9511de02c9b7332bd 100644 (file)
--- a/src/source-af-packet.c
+++ b/src/source-af-packet.c
@@ -311,7 +311,7 @@ TmEcode ReceiveAFPLoop(ThreadVars *tv, void *data, void *slot);
 
 TmEcode DecodeAFPThreadInit(ThreadVars *, const void *, void **);
 TmEcode DecodeAFPThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodeAFP(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode DecodeAFP(ThreadVars *, Packet *, void *, PacketQueue *);
 
 TmEcode AFPSetBPFFilter(AFPThreadVars *ptv);
 static int AFPGetIfnumByDev(int fd, const char *ifname, int verbose);
@@ -2887,7 +2887,7 @@ TmEcode ReceiveAFPThreadDeinit(ThreadVars *tv, void *data)
  * \param data pointer that gets cast into AFPThreadVars for ptv
  * \param pq pointer to the current PacketQueue
  */
-TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;

diff --git a/src/source-erf-dag.c b/src/source-erf-dag.c
index 9d4e34fc54ca43e41e472100138c8e800afcece9..d2574661622e831b00f34df238bbc6b68a2166cc 100644 (file)
--- a/src/source-erf-dag.c
+++ b/src/source-erf-dag.c
@@ -610,8 +610,7 @@ ReceiveErfDagCloseStream(int dagfd, int stream)
  * \param pq pointer to the current PacketQueue
  */
 TmEcode
-DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
-    PacketQueue *postpq)
+DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;

diff --git a/src/source-erf-file.c b/src/source-erf-file.c
index f51e8fe79c5aed036044e662e711aac10464f62e..85dd452b44f904a5cded5a02a0da5cc80108f29a 100644 (file)
--- a/src/source-erf-file.c
+++ b/src/source-erf-file.c
@@ -68,9 +68,9 @@ TmEcode ReceiveErfFileThreadInit(ThreadVars *, const void *, void **);
 void ReceiveErfFileThreadExitStats(ThreadVars *, void *);
 TmEcode ReceiveErfFileThreadDeinit(ThreadVars *, void *);
 
-TmEcode DecodeErfFileThreadInit(ThreadVars *, const void *, void **);
-TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodeErfFile(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+static TmEcode DecodeErfFileThreadInit(ThreadVars *, const void *, void **);
+static TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data);
+static TmEcode DecodeErfFile(ThreadVars *, Packet *, void *, PacketQueue *);
 
 /**
  * \brief Register the ERF file receiver (reader) module.
@@ -275,7 +275,7 @@ TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data)
  * off to the ethernet decoder.
  */
 TmEcode
-DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;

diff --git a/src/source-ipfw.c b/src/source-ipfw.c
index 008189822857a121e4cd34fc801e93bd230601ac..1fc8dabbe252a4cb2860bbb2e3292e5045e4d0cd 100644 (file)
--- a/src/source-ipfw.c
+++ b/src/source-ipfw.c
@@ -131,20 +131,20 @@ static SCMutex ipfw_init_lock;
 /* IPFW Prototypes */
 void *IPFWGetQueue(int number);
 TmEcode ReceiveIPFWThreadInit(ThreadVars *, const void *, void **);
-TmEcode ReceiveIPFW(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode ReceiveIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode ReceiveIPFWLoop(ThreadVars *tv, void *data, void *slot);
 void ReceiveIPFWThreadExitStats(ThreadVars *, void *);
 TmEcode ReceiveIPFWThreadDeinit(ThreadVars *, void *);
 
 TmEcode IPFWSetVerdict(ThreadVars *, IPFWThreadVars *, Packet *);
-TmEcode VerdictIPFW(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode VerdictIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode VerdictIPFWThreadInit(ThreadVars *, const void *, void **);
 void VerdictIPFWThreadExitStats(ThreadVars *, void *);
 TmEcode VerdictIPFWThreadDeinit(ThreadVars *, void *);
 
 TmEcode DecodeIPFWThreadInit(ThreadVars *, const void *, void **);
 TmEcode DecodeIPFWThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodeIPFW(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode DecodeIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
 
 /**
  * \brief Registration Function for RecieveIPFW.
@@ -439,7 +439,7 @@ TmEcode ReceiveIPFWThreadDeinit(ThreadVars *tv, void *data)
  * \param data pointer that gets cast into IPFWThreadVars for ptv
  * \param pq pointer to the PacketQueue
  */
-TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
     IPV6Hdr *ip6h = (IPV6Hdr *)GET_PKT_DATA(p);
@@ -613,7 +613,7 @@ TmEcode IPFWSetVerdict(ThreadVars *tv, IPFWThreadVars *ptv, Packet *p)
  * \param data pointer that gets cast into IPFWThreadVars for ptv
  * \param pq pointer for the Packet Queue access (Not used)
  */
-TmEcode VerdictIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode VerdictIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     IPFWThreadVars *ptv = (IPFWThreadVars *)data;
     TmEcode retval = TM_ECODE_OK;

diff --git a/src/source-napatech.c b/src/source-napatech.c
index 2b9ba58ec2bbcc3efbad99d919f2557038ba49bf..e97bf66180f849857b86cfec6feba63f44acb1ec 100644 (file)
--- a/src/source-napatech.c
+++ b/src/source-napatech.c
@@ -542,8 +542,7 @@ TmEcode NapatechStreamThreadDeinit(ThreadVars *tv, void *data)
  * \param data pointer that gets cast into PcapThreadVars for ptv
  * \param pq pointer to the current PacketQueue
  */
-TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
-        PacketQueue *postpq)
+TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
 

diff --git a/src/source-netmap.c b/src/source-netmap.c
index 3cea7dc691f09bba7f4afbf40437fb778b14220e..579ad1295b373459f57b00a766958d13b43e0640 100644 (file)
--- a/src/source-netmap.c
+++ b/src/source-netmap.c
@@ -746,9 +746,8 @@ static TmEcode DecodeNetmapThreadInit(ThreadVars *tv, const void *initdata, void
  * \param p pointer to the current packet
  * \param data pointer that gets cast into NetmapThreadVars for ntv
  * \param pq pointer to the current PacketQueue
- * \param postpq
  */
-static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
 

diff --git a/src/source-nflog.c b/src/source-nflog.c
index 38ddd309024155c0604844742c69727012e8d645..e5929c65a5c39af6eefdca250c954ebe99b5962e 100644 (file)
--- a/src/source-nflog.c
+++ b/src/source-nflog.c
@@ -75,7 +75,7 @@ void ReceiveNFLOGThreadExitStats(ThreadVars *, void *);
 
 TmEcode DecodeNFLOGThreadInit(ThreadVars *, const void *, void **);
 TmEcode DecodeNFLOGThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodeNFLOG(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode DecodeNFLOG(ThreadVars *, Packet *, void *, PacketQueue *);
 
 static int runmode_workers;
 
@@ -501,7 +501,7 @@ void ReceiveNFLOGThreadExitStats(ThreadVars *tv, void *data)
  *
  * \retval TM_ECODE_OK is always returned
  */
-TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
     IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);

diff --git a/src/source-nfq.c b/src/source-nfq.c
index a0cab39b5e19c4eb7698a53f3c156f1adbdb005a..d5859be2f8279a5f087f2031e56c9098cac7ca53 100644 (file)
--- a/src/source-nfq.c
+++ b/src/source-nfq.c
@@ -137,11 +137,11 @@ TmEcode ReceiveNFQThreadInit(ThreadVars *, const void *, void **);
 TmEcode ReceiveNFQThreadDeinit(ThreadVars *, void *);
 void ReceiveNFQThreadExitStats(ThreadVars *, void *);
 
-TmEcode VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode VerdictNFQThreadInit(ThreadVars *, const void *, void **);
 TmEcode VerdictNFQThreadDeinit(ThreadVars *, void *);
 
-TmEcode DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode DecodeNFQThreadInit(ThreadVars *, const void *, void **);
 TmEcode DecodeNFQThreadDeinit(ThreadVars *tv, void *data);
 
@@ -1199,7 +1199,7 @@ TmEcode NFQSetVerdict(Packet *p)
 /**
  * \brief NFQ verdict module packet entry function
  */
-TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     NFQThreadVars *ntv = (NFQThreadVars *)data;
     /* update counters */
@@ -1230,7 +1230,7 @@ TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
 /**
  * \brief Decode a packet coming from NFQ
  */
-TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
 
     IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);

diff --git a/src/source-pcap-file.c b/src/source-pcap-file.c
index 035c63e11a26cf11d0d3df57b4f586ecb3f0a2b0..425032b846336fcccef1dd648cf08cc96b7b568a 100644 (file)
--- a/src/source-pcap-file.c
+++ b/src/source-pcap-file.c
@@ -58,8 +58,7 @@ static TmEcode ReceivePcapFileThreadInit(ThreadVars *, const void *, void **);
 static void ReceivePcapFileThreadExitStats(ThreadVars *, void *);
 static TmEcode ReceivePcapFileThreadDeinit(ThreadVars *, void *);
 
-static TmEcode DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *,
-                              PacketQueue *);
+static TmEcode DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
 static TmEcode DecodePcapFileThreadInit(ThreadVars *, const void *, void **);
 static TmEcode DecodePcapFileThreadDeinit(ThreadVars *tv, void *data);
 
@@ -390,7 +389,7 @@ TmEcode ReceivePcapFileThreadDeinit(ThreadVars *tv, void *data)
 
 static double prev_signaled_ts = 0;
 
-TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+static TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;

diff --git a/src/source-pcap.c b/src/source-pcap.c
index 0c078748a74a957d69399ab08df1c1143b7d9e1d..9ec461508c94de418548fceba9e1f9dcdc2b65fc 100644 (file)
--- a/src/source-pcap.c
+++ b/src/source-pcap.c
@@ -98,7 +98,7 @@ TmEcode ReceivePcapBreakLoop(ThreadVars *tv, void *data);
 
 TmEcode DecodePcapThreadInit(ThreadVars *, const void *, void **);
 TmEcode DecodePcapThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *);
 
 /** protect pcap_compile and pcap_setfilter, as they are not thread safe:
  *  http://seclists.org/tcpdump/2009/q1/62 */
@@ -555,7 +555,7 @@ TmEcode ReceivePcapThreadDeinit(ThreadVars *tv, void *data)
  * \param data pointer that gets cast into PcapThreadVars for ptv
  * \param pq pointer to the current PacketQueue
  */
-TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;

diff --git a/src/source-pfring.c b/src/source-pfring.c
index 8976f61359192ea9f1f1b902a49d8b27b39582c4..82a0bb85eca9a3dbe573c7d0debf05e47f8aea54 100644 (file)
--- a/src/source-pfring.c
+++ b/src/source-pfring.c
@@ -53,7 +53,7 @@ void ReceivePfringThreadExitStats(ThreadVars *, void *);
 TmEcode ReceivePfringThreadDeinit(ThreadVars *, void *);
 
 TmEcode DecodePfringThreadInit(ThreadVars *, const void *, void **);
-TmEcode DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode DecodePfringThreadDeinit(ThreadVars *tv, void *data);
 
 extern int max_pending_packets;
@@ -720,7 +720,7 @@ TmEcode ReceivePfringThreadDeinit(ThreadVars *tv, void *data)
  *
  * \retval TM_ECODE_OK is always returned
  */
-TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 

diff --git a/src/source-windivert.c b/src/source-windivert.c
index 1c549712d8b5487004c24592d7c6331ce0048cbd..30c8aa3b5046e854ec2f9d96f31cc8d119583e38 100644 (file)
--- a/src/source-windivert.c
+++ b/src/source-windivert.c
@@ -347,14 +347,12 @@ TmEcode ReceiveWinDivertThreadDeinit(ThreadVars *, void *);
 void ReceiveWinDivertThreadExitStats(ThreadVars *, void *);
 
 /* Verdict functions */
-TmEcode VerdictWinDivert(ThreadVars *, Packet *, void *, PacketQueue *,
-                         PacketQueue *);
+TmEcode VerdictWinDivert(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode VerdictWinDivertThreadInit(ThreadVars *, const void *, void **);
 TmEcode VerdictWinDivertThreadDeinit(ThreadVars *, void *);
 
 /* Decode functions */
-TmEcode DecodeWinDivert(ThreadVars *, Packet *, void *, PacketQueue *,
-                        PacketQueue *);
+TmEcode DecodeWinDivert(ThreadVars *, Packet *, void *, PacketQueue *);
 TmEcode DecodeWinDivertThreadInit(ThreadVars *, const void *, void **);
 TmEcode DecodeWinDivertThreadDeinit(ThreadVars *, void *);
 
@@ -734,8 +732,7 @@ void ReceiveWinDivertThreadExitStats(ThreadVars *tv, void *data)
 /**
  * \brief WinDivert verdict module packet entry function
  */
-TmEcode VerdictWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
-                         PacketQueue *postpq)
+TmEcode VerdictWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq);
 {
     SCEnter();
 
@@ -859,8 +856,7 @@ TmEcode VerdictWinDivertThreadDeinit(ThreadVars *tv, void *data)
  * to differentiate the two, so instead we must check the version and go
  * from there.
  */
-TmEcode DecodeWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
-                        PacketQueue *postpq)
+TmEcode DecodeWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     SCEnter();
 
@@ -1018,4 +1014,4 @@ void SourceWinDivertRegisterTests()
 #endif
 }
 
-#endif /* WINDIVERT */
\ No newline at end of file
+#endif /* WINDIVERT */

diff --git a/src/stream-tcp.c b/src/stream-tcp.c
index df392376ba752522ad4e2d467be62f5795da4977..6a771cfb6bd89ed096050fcb3bbf60a0d11d42ad 100644 (file)
--- a/src/stream-tcp.c
+++ b/src/stream-tcp.c
@@ -5177,7 +5177,7 @@ int TcpSessionPacketSsnReuse(const Packet *p, const Flow *f, const void *tcp_ssn
     return 0;
 }
 
-TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueue *postpq)
+TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
 {
     StreamTcpThread *stt = (StreamTcpThread *)data;
 

diff --git a/src/stream-tcp.h b/src/stream-tcp.h
index e243eebb5ef7b0cd084ce7347dcfa1102cfe7e8b..4e5f55c8cc1541aa241b619cc4b0bd92fc03c488 100644 (file)
--- a/src/stream-tcp.h
+++ b/src/stream-tcp.h
@@ -172,7 +172,7 @@ enum {
     STREAM_HAS_UNPROCESSED_SEGMENTS_NEED_ONLY_DETECTION = 1,
 };
 
-TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *);
 int StreamNeedsReassembly(const TcpSession *ssn, uint8_t direction);
 TmEcode StreamTcpThreadInit(ThreadVars *, void *, void **);
 TmEcode StreamTcpThreadDeinit(ThreadVars *tv, void *data);

diff --git a/src/tests/detect.c b/src/tests/detect.c
index 81fc254cf7a3e6c1ecf4cb0b8262e5ccddb049fe..c11aaf2b9ea223587b9dbf401eb32f897eb7a94d 100644 (file)
--- a/src/tests/detect.c
+++ b/src/tests/detect.c
@@ -3661,7 +3661,7 @@ static int SigTest40NoPacketInspection01(void)
     DetectEngineThreadCtxInit(&th_v, (void *)de_ctx,(void *)&det_ctx);
     det_ctx->de_ctx = de_ctx;
 
-    Detect(&th_v, p, det_ctx, &pq, NULL);
+    Detect(&th_v, p, det_ctx);
     if (PacketAlertCheck(p, 2))
         result = 0;
     else
@@ -4432,20 +4432,20 @@ static int SigTestDetectAlertCounter(void)
     StatsSetupPrivate(&tv);
 
     p = UTHBuildPacket((uint8_t *)"boo", strlen("boo"), IPPROTO_TCP);
-    Detect(&tv, p, det_ctx, NULL, NULL);
+    Detect(&tv, p, det_ctx);
     FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 1);
 
-    Detect(&tv, p, det_ctx, NULL, NULL);
+    Detect(&tv, p, det_ctx);
     FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 2);
     UTHFreePackets(&p, 1);
 
     p = UTHBuildPacket((uint8_t *)"roo", strlen("roo"), IPPROTO_TCP);
-    Detect(&tv, p, det_ctx, NULL, NULL);
+    Detect(&tv, p, det_ctx);
     FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 2);
     UTHFreePackets(&p, 1);
 
     p = UTHBuildPacket((uint8_t *)"laboosa", strlen("laboosa"), IPPROTO_TCP);
-    Detect(&tv, p, det_ctx, NULL, NULL);
+    Detect(&tv, p, det_ctx);
     FAIL_IF_NOT(StatsGetLocalCounterValue(&tv, det_ctx->counter_alerts) == 3);
     UTHFreePackets(&p, 1);
 

diff --git a/src/tm-modules.h b/src/tm-modules.h
index 5d41de617b629c1059b7f762534dfa4946fa0aa0..072900857b8d5b1af16df83368f11701001aac45 100644 (file)
--- a/src/tm-modules.h
+++ b/src/tm-modules.h
@@ -49,7 +49,7 @@ typedef struct TmModule_ {
     TmEcode (*ThreadDeinit)(ThreadVars *, void *);
 
     /** the packet processing function */
-    TmEcode (*Func)(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+    TmEcode (*Func)(ThreadVars *, Packet *, void *, PacketQueue *);
 
     TmEcode (*PktAcqLoop)(ThreadVars *, void *, void *);
 

diff --git a/src/tm-threads.c b/src/tm-threads.c
index caa32d36640cb1b86b08f6bfaba1de064586c38c..94e9bf310eac491a7df0dfad009ca27864465f71 100644 (file)
--- a/src/tm-threads.c
+++ b/src/tm-threads.c
@@ -116,12 +116,8 @@ TmEcode TmThreadsSlotVarRun(ThreadVars *tv, Packet *p, TmSlot *slot)
 {
     for (TmSlot *s = slot; s != NULL; s = s->slot_next) {
         PACKET_PROFILING_TMM_START(p, s->tm_id);
-        PacketQueue *post_pq = &s->slot_post_pq;
-        if (s->id > 0) {
-            post_pq = NULL;
-        }
         TmEcode r = s->SlotFunc(tv, p, SC_ATOMIC_GET(s->slot_data),
-                &s->slot_pre_pq, post_pq);
+                &s->slot_pre_pq);
         PACKET_PROFILING_TMM_END(p, s->tm_id);
 
         /* handle error */

diff --git a/src/tm-threads.h b/src/tm-threads.h
index 805dc4ca494a83eea4728ab7ff006acf4edd72e5..ca7541357cd57b7efa312b22259969caeee9a857 100644 (file)
--- a/src/tm-threads.h
+++ b/src/tm-threads.h
@@ -47,8 +47,7 @@ static inline void SleepUsec(uint64_t usec)
 #define TM_QUEUE_NAME_MAX 16
 #define TM_THREAD_NAME_MAX 16
 
-typedef TmEcode (*TmSlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *,
-                        PacketQueue *);
+typedef TmEcode (*TmSlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *);
 
 typedef struct TmSlot_ {
     /* the TV holding this slot */