{
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
void *data = NULL;
OutputInitResult oc;
LogFileCtx *lf;
memset(&dtv, 0, sizeof(DecodeThreadVars));
memset(&tv, 0, sizeof(ThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
memset(&s, 0, sizeof(Signature));
p->alerts.cnt++;
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&tv, &dtv, p, raw_ipv4_tcp, sizeof(raw_ipv4_tcp), &pq);
-
+ DecodeEthernet(&tv, &dtv, p, raw_ipv4_tcp, sizeof(raw_ipv4_tcp));
oc = Unified2AlertInitCtx(NULL);
if (oc.ctx == NULL) {
{
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
void *data = NULL;
OutputInitResult oc;
LogFileCtx *lf;
memset(&dtv, 0, sizeof(DecodeThreadVars));
memset(&tv, 0, sizeof(ThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
memset(&s, 0, sizeof(Signature));
p->alerts.cnt++;
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&tv, &dtv, p, raw_ipv6_tcp, sizeof(raw_ipv6_tcp), &pq);
+ DecodeEthernet(&tv, &dtv, p, raw_ipv6_tcp, sizeof(raw_ipv6_tcp));
oc = Unified2AlertInitCtx(NULL);
if (oc.ctx == NULL) {
{
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
void *data = NULL;
OutputInitResult oc;
LogFileCtx *lf;
memset(&dtv, 0, sizeof(DecodeThreadVars));
memset(&tv, 0, sizeof(ThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
memset(&s, 0, sizeof(Signature));
p->alerts.cnt++;
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&tv, &dtv, p, raw_gre, sizeof(raw_gre), &pq);
+ DecodeEthernet(&tv, &dtv, p, raw_gre, sizeof(raw_gre));
oc = Unified2AlertInitCtx(NULL);
if (oc.ctx == NULL) {
Unified2AlertDeInitCtx(oc.ctx);
- pkt = PacketDequeue(&pq);
+ pkt = PacketDequeueNoLock(&tv.decode_pq);
while (pkt != NULL) {
PACKET_RECYCLE(pkt);
SCFree(pkt);
- pkt = PacketDequeue(&pq);
+ pkt = PacketDequeueNoLock(&tv.decode_pq);
}
PACKET_RECYCLE(p);
return 1;
end:
- pkt = PacketDequeue(&pq);
+ pkt = PacketDequeueNoLock(&tv.decode_pq);
while (pkt != NULL) {
PACKET_RECYCLE(pkt);
SCFree(pkt);
- pkt = PacketDequeue(&pq);
+ pkt = PacketDequeueNoLock(&tv.decode_pq);
}
PACKET_RECYCLE(p);
SCFree(p);
{
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
void *data = NULL;
OutputInitResult oc;
LogFileCtx *lf;
memset(&dtv, 0, sizeof(DecodeThreadVars));
memset(&tv, 0, sizeof(ThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
memset(&s, 0, sizeof(Signature));
p->alerts.cnt++;
FlowInitConfig(FLOW_QUIET);
- DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp), &pq);
+ DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp));
oc = Unified2AlertInitCtx(NULL);
if (oc.ctx == NULL) {
{
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
void *data = NULL;
OutputInitResult oc;
LogFileCtx *lf;
memset(&dtv, 0, sizeof(DecodeThreadVars));
memset(&tv, 0, sizeof(ThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
memset(&s, 0, sizeof(Signature));
p->alerts.cnt++;
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&tv, &dtv, p, raw_ipv4_tcp, sizeof(raw_ipv4_tcp), &pq);
+ DecodeEthernet(&tv, &dtv, p, raw_ipv4_tcp, sizeof(raw_ipv4_tcp));
p->action = ACTION_DROP;
#ifdef AFLFUZZ_DECODER
int AFLDecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
- return DecodeIPV4(tv, dtv, p, pkt, (uint16_t)len, pq);
+ return DecodeIPV4(tv, dtv, p, pkt, (uint16_t)len);
}
int AFLDecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
- return DecodeIPV6(tv, dtv, p, pkt, (uint16_t)len, pq);
+ return DecodeIPV6(tv, dtv, p, pkt, (uint16_t)len);
}
/* stateful processing of data as packets. Because AFL in case of a
Packet *p = PacketGetFromAlloc();
if (p != NULL) {
PacketSetData(p, buffer, size);
- (void) Decoder (&tv, dtv, p, buffer, size, &pq);
+ (void) Decoder (&tv, dtv, p, buffer, size);
while (1) {
- Packet *extra_p = PacketDequeue(&pq);
+ Packet *extra_p = PacketDequeueNoLock(&tv.decode_pq);
if (unlikely(extra_p == NULL))
break;
PacketFree(extra_p);
Packet *p = PacketGetFromAlloc();
if (p != NULL) {
PacketSetData(p, buffer, size);
- (void) Decoder (&tv, dtv, p, buffer, size, &pq);
+ (void) Decoder (&tv, dtv, p, buffer, size);
while (1) {
- Packet *extra_p = PacketDequeue(&pq);
+ Packet *extra_p = PacketDequeueNoLock(&tv.decode_pq);
if (unlikely(extra_p == NULL))
break;
PacketFree(extra_p);
* \brief Function to decode ERSPAN packets
*/
-int DecodeERSPAN(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+int DecodeERSPAN(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_erspan);
p->vlan_idx++;
}
- return DecodeEthernet(tv, dtv, p, pkt + sizeof(ErspanHdr), len - sizeof(ErspanHdr), pq);
+ return DecodeEthernet(tv, dtv, p, pkt + sizeof(ErspanHdr), len - sizeof(ErspanHdr));
}
/**
#include "util-debug.h"
int DecodeEthernet(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_eth);
case ETHERNET_TYPE_IP:
//printf("DecodeEthernet ip4\n");
DecodeIPV4(tv, dtv, p, pkt + ETHERNET_HEADER_LEN,
- len - ETHERNET_HEADER_LEN, pq);
+ len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_IPV6:
//printf("DecodeEthernet ip6\n");
DecodeIPV6(tv, dtv, p, pkt + ETHERNET_HEADER_LEN,
- len - ETHERNET_HEADER_LEN, pq);
+ len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_PPPOE_SESS:
//printf("DecodeEthernet PPPOE Session\n");
DecodePPPOESession(tv, dtv, p, pkt + ETHERNET_HEADER_LEN,
- len - ETHERNET_HEADER_LEN, pq);
+ len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_PPPOE_DISC:
//printf("DecodeEthernet PPPOE Discovery\n");
DecodePPPOEDiscovery(tv, dtv, p, pkt + ETHERNET_HEADER_LEN,
- len - ETHERNET_HEADER_LEN, pq);
+ len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_VLAN:
case ETHERNET_TYPE_8021QINQ:
DecodeVLAN(tv, dtv, p, pkt + ETHERNET_HEADER_LEN,
- len - ETHERNET_HEADER_LEN, pq);
+ len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_MPLS_UNICAST:
case ETHERNET_TYPE_MPLS_MULTICAST:
DecodeMPLS(tv, dtv, p, pkt + ETHERNET_HEADER_LEN,
- len - ETHERNET_HEADER_LEN, pq);
+ len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_DCE:
if (unlikely(len < ETHERNET_DCE_HEADER_LEN)) {
ENGINE_SET_INVALID_EVENT(p, DCE_PKT_TOO_SMALL);
} else {
DecodeEthernet(tv, dtv, p, pkt + ETHERNET_DCE_HEADER_LEN,
- len - ETHERNET_DCE_HEADER_LEN, pq);
+ len - ETHERNET_DCE_HEADER_LEN);
}
break;
default:
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth));
SCFree(p);
return 1;
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth));
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p, DCE_PKT_TOO_SMALL));
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth));
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p, ETHERNET_PKT_TOO_SMALL));
* \brief Function to decode GRE packets
*/
-int DecodeGRE(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+int DecodeGRE(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len)
{
uint32_t header_len = GRE_HDR_LEN;
GRESreHdr *gsre = NULL;
switch (GRE_GET_PROTO(p->greh))
{
case ETHERNET_TYPE_IP:
- {
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
- len - header_len, DECODE_TUNNEL_IPV4, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
- PacketEnqueue(pq,tp);
- }
- }
- break;
+ {
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
+ len - header_len, DECODE_TUNNEL_IPV4);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
+ break;
+ }
case GRE_PROTO_PPP:
- {
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
- len - header_len, DECODE_TUNNEL_PPP, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
- PacketEnqueue(pq,tp);
- }
- }
- break;
+ {
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
+ len - header_len, DECODE_TUNNEL_PPP);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
+ break;
+ }
case ETHERNET_TYPE_IPV6:
- {
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
- len - header_len, DECODE_TUNNEL_IPV6, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
- PacketEnqueue(pq,tp);
- }
- }
- break;
+ {
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
+ len - header_len, DECODE_TUNNEL_IPV6);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
+ break;
+ }
case ETHERNET_TYPE_VLAN:
- {
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
- len - header_len, DECODE_TUNNEL_VLAN, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
- PacketEnqueue(pq,tp);
- }
- }
- break;
+ {
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
+ len - header_len, DECODE_TUNNEL_VLAN);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
+ break;
+ }
case ETHERNET_TYPE_ERSPAN:
{
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
- len - header_len, DECODE_TUNNEL_ERSPAN, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
- PacketEnqueue(pq,tp);
- }
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
+ len - header_len, DECODE_TUNNEL_ERSPAN);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
break;
}
case ETHERNET_TYPE_BRIDGE:
- {
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
- len - header_len, DECODE_TUNNEL_ETHERNET, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
- PacketEnqueue(pq,tp);
- }
- }
- break;
+ {
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + header_len,
+ len - header_len, DECODE_TUNNEL_ETHERNET);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_GRE);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
+ break;
+ }
default:
return TM_ECODE_OK;
static int DecodeGREtest01 (void)
{
-
uint8_t raw_gre[] = { 0x00 ,0x6e ,0x62 };
Packet *p = PacketGetFromAlloc();
if (unlikely(p == NULL))
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodeGRE(&tv, &dtv, p, raw_gre, sizeof(raw_gre), NULL);
+ DecodeGRE(&tv, &dtv, p, raw_gre, sizeof(raw_gre));
if(ENGINE_ISSET_EVENT(p,GRE_PKT_TOO_SMALL)) {
SCFree(p);
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodeGRE(&tv, &dtv, p, raw_gre, sizeof(raw_gre), NULL);
+ DecodeGRE(&tv, &dtv, p, raw_gre, sizeof(raw_gre));
if(ENGINE_ISSET_EVENT(p,GRE_WRONG_VERSION)) {
SCFree(p);
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodeGRE(&tv, &dtv, p, raw_gre, sizeof(raw_gre), NULL);
+ DecodeGRE(&tv, &dtv, p, raw_gre, sizeof(raw_gre));
if(p->greh == NULL) {
SCFree(p);
/** DecodeICMPV4
* \brief Main ICMPv4 decoding function
*/
-int DecodeICMPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+int DecodeICMPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_icmpv4);
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if (NULL!=p->icmpv4h) {
if (p->icmpv4h->type==8 && p->icmpv4h->code==0) {
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if (NULL!=p->icmpv4h) {
if (p->icmpv4h->type==0 && p->icmpv4h->code==0) {
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if (NULL == p->icmpv4h) {
printf("NULL == p->icmpv4h: ");
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if (NULL == p->icmpv4h) {
goto end;
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if (NULL == p->icmpv4h) {
goto end;
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if(ENGINE_ISSET_EVENT(p,ICMPV4_UNKNOWN_TYPE)) {
ret = 1;
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&tv, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
if (NULL!=p->icmpv4h) {
if (p->icmpv4h->type==8 && p->icmpv4h->code==0) {
* \param p Pointer to the packet we are filling
* \param pkt Pointer to the raw packet buffer
* \param len the len of the rest of the packet not processed yet
- * \param pq the packet queue were this packet go
*
* \retval void No return value
*/
int DecodeICMPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
int full_hdr = 0;
StatsIncr(tv, dtv->counter_icmpv6);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(p->icmpv6h == NULL);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(p->icmpv6h == NULL);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->icmpv6h);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->icmpv6h);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->icmpv6h);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->icmpv6h);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->icmpv6h);
FAIL_IF(ICMPV6_GET_TYPE(p) != 4 || ICMPV6_GET_CODE(p) != 0);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->icmpv6h);
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_PKT_TOO_SMALL));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_IPV6_TRUNC_PKT));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF_NULL(p->payload);
FAIL_IF(p->payload_len != 37);
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6, sizeof(raw_ipv6));
FAIL_IF(!ENGINE_ISSET_EVENT(p, ICMPV6_UNKNOWN_CODE));
memset(&ip6h, 0, sizeof(IPV6Hdr));
FlowInitConfig(FLOW_QUIET);
- DecodeIPV6(&tv, &dtv, p, raw_ipv6 + 14, sizeof(raw_ipv6) - 14, NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_ipv6 + 14, sizeof(raw_ipv6) - 14);
FAIL_IF_NULL(p->icmpv6h);
uint16_t icmpv6_len = IPV6_GET_RAW_PLEN(p->ip6h) -
}
int DecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
StatsIncr(tv, dtv->counter_ipv4);
/* If a fragment, pass off for re-assembly. */
if (unlikely(IPV4_GET_IPOFFSET(p) > 0 || IPV4_GET_MF(p) == 1)) {
- Packet *rp = Defrag(tv, dtv, p, pq);
+ Packet *rp = Defrag(tv, dtv, p);
if (rp != NULL) {
- PacketEnqueue(pq, rp);
+ PacketEnqueueNoLock(&tv->decode_pq, rp);
}
p->flags |= PKT_IS_FRAGMENT;
return TM_ECODE_OK;
switch (IPV4_GET_IPPROTO(p)) {
case IPPROTO_TCP:
DecodeTCP(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p), pq);
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p));
break;
case IPPROTO_UDP:
DecodeUDP(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p), pq);
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p));
break;
case IPPROTO_ICMP:
DecodeICMPV4(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p), pq);
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p));
break;
case IPPROTO_GRE:
DecodeGRE(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p), pq);
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p));
break;
case IPPROTO_SCTP:
DecodeSCTP(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p), pq);
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p));
break;
case IPPROTO_IPV6:
{
- if (pq != NULL) {
- /* spawn off tunnel packet */
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p),
- DECODE_TUNNEL_IPV6, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV4);
- PacketEnqueue(pq,tp);
- }
- FlowSetupPacket(p);
+ /* spawn off tunnel packet */
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p),
+ DECODE_TUNNEL_IPV6);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV4);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
}
+ FlowSetupPacket(p);
break;
}
case IPPROTO_IP:
/* check PPP VJ uncompressed packets and decode tcp dummy */
if(p->ppph != NULL && SCNtohs(p->ppph->protocol) == PPP_VJ_UCOMP) {
DecodeTCP(tv, dtv, p, pkt + IPV4_GET_HLEN(p),
- IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p), pq);
+ IPV4_GET_IPLEN(p) - IPV4_GET_HLEN(p));
}
break;
case IPPROTO_ICMPV6:
return 0;
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
int result = 1;
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
FlowInitConfig(FLOW_QUIET);
DefragInit();
PacketCopyData(p, pkt1, sizeof(pkt1));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
result = 0;
PacketCopyData(p, pkt2, sizeof(pkt2));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
result = 0;
PacketCopyData(p, pkt3, sizeof(pkt3));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
result = 0;
goto end;
}
- Packet *tp = PacketDequeue(&pq);
+ Packet *tp = PacketDequeueNoLock(&tv.decode_pq);
if (tp == NULL) {
printf("Failed to get defragged pseudo packet\n");
result = 0;
return 0;
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
int result = 0;
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
FlowInitConfig(FLOW_QUIET);
DefragInit();
PacketCopyData(p, pkt1, sizeof(pkt1));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
goto end;
PacketCopyData(p, pkt2, sizeof(pkt2));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
goto end;
p->recursion_level = 3;
PacketCopyData(p, pkt3, sizeof(pkt3));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
goto end;
}
- Packet *tp = PacketDequeue(&pq);
+ Packet *tp = PacketDequeueNoLock(&tv.decode_pq);
if (tp == NULL) {
printf("Failed to get defragged pseudo packet\n");
goto end;
return 0;
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
int result = 1;
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- memset(&pq, 0, sizeof(PacketQueue));
FlowInitConfig(FLOW_QUIET);
DefragInit();
PacketCopyData(p, pkt, sizeof(pkt));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph == NULL) {
printf("tcp header shouldn't be NULL, but it is\n");
result = 0;
PacketCopyData(p, pkt1, sizeof(pkt1));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
result = 0;
PacketCopyData(p, pkt2, sizeof(pkt2));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
result = 0;
PacketCopyData(p, pkt3, sizeof(pkt3));
DecodeIPV4(&tv, &dtv, p, GET_PKT_DATA(p) + ETHERNET_HEADER_LEN,
- GET_PKT_LEN(p) - ETHERNET_HEADER_LEN, &pq);
+ GET_PKT_LEN(p) - ETHERNET_HEADER_LEN);
if (p->tcph != NULL) {
printf("tcp header should be NULL for ip fragment, but it isn't\n");
result = 0;
goto end;
}
- Packet *tp = PacketDequeue(&pq);
+ Packet *tp = PacketDequeueNoLock(&tv.decode_pq);
if (tp == NULL) {
printf("Failed to get defragged pseudo packet\n");
result = 0;
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth));
SCFree(p);
DefragDestroy();
* \brief Function to decode IPv4 in IPv6 packets
*
*/
-static void DecodeIPv4inIPv6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint16_t plen, PacketQueue *pq)
+static void DecodeIPv4inIPv6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint16_t plen)
{
if (unlikely(plen < IPV4_HEADER_LEN)) {
return;
}
if (IP_GET_RAW_VER(pkt) == 4) {
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt, plen, DECODE_TUNNEL_IPV4, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
- /* add the tp to the packet queue. */
- PacketEnqueue(pq,tp);
- StatsIncr(tv, dtv->counter_ipv4inipv6);
- return;
- }
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt, plen, DECODE_TUNNEL_IPV4);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
+ StatsIncr(tv, dtv->counter_ipv4inipv6);
+ return;
}
} else {
ENGINE_SET_EVENT(p, IPV4_IN_IPV6_WRONG_IP_VER);
*
*/
static int DecodeIP6inIP6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t plen, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t plen)
{
if (unlikely(plen < IPV6_HEADER_LEN)) {
return TM_ECODE_FAILED;
}
if (IP_GET_RAW_VER(pkt) == 6) {
- if (unlikely(pq != NULL)) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt, plen, DECODE_TUNNEL_IPV6, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
- PacketEnqueue(pq,tp);
- StatsIncr(tv, dtv->counter_ipv6inipv6);
- }
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt, plen, DECODE_TUNNEL_IPV6);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
+ StatsIncr(tv, dtv->counter_ipv6inipv6);
}
} else {
ENGINE_SET_EVENT(p, IPV6_IN_IPV6_WRONG_IP_VER);
static void
DecodeIPV6ExtHdrs(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
SCEnter();
{
case IPPROTO_TCP:
IPV6_SET_L4PROTO(p,nh);
- DecodeTCP(tv, dtv, p, pkt, plen, pq);
+ DecodeTCP(tv, dtv, p, pkt, plen);
SCReturn;
case IPPROTO_UDP:
IPV6_SET_L4PROTO(p,nh);
- DecodeUDP(tv, dtv, p, pkt, plen, pq);
+ DecodeUDP(tv, dtv, p, pkt, plen);
SCReturn;
case IPPROTO_ICMPV6:
IPV6_SET_L4PROTO(p,nh);
- DecodeICMPV6(tv, dtv, p, pkt, plen, pq);
+ DecodeICMPV6(tv, dtv, p, pkt, plen);
SCReturn;
case IPPROTO_SCTP:
IPV6_SET_L4PROTO(p,nh);
- DecodeSCTP(tv, dtv, p, pkt, plen, pq);
+ DecodeSCTP(tv, dtv, p, pkt, plen);
SCReturn;
case IPPROTO_ROUTING:
}
case IPPROTO_IPIP:
IPV6_SET_L4PROTO(p,nh);
- DecodeIPv4inIPv6(tv, dtv, p, pkt, plen, pq);
+ DecodeIPv4inIPv6(tv, dtv, p, pkt, plen);
SCReturn;
/* none, last header */
case IPPROTO_NONE:
return 0;
}
-int DecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+int DecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, const uint8_t *pkt, uint16_t len)
{
StatsIncr(tv, dtv->counter_ipv6);
switch(IPV6_GET_NH(p)) {
case IPPROTO_TCP:
IPV6_SET_L4PROTO (p, IPPROTO_TCP);
- DecodeTCP(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeTCP(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
return TM_ECODE_OK;
case IPPROTO_UDP:
IPV6_SET_L4PROTO (p, IPPROTO_UDP);
- DecodeUDP(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeUDP(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
return TM_ECODE_OK;
case IPPROTO_ICMPV6:
IPV6_SET_L4PROTO (p, IPPROTO_ICMPV6);
- DecodeICMPV6(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeICMPV6(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
return TM_ECODE_OK;
case IPPROTO_SCTP:
IPV6_SET_L4PROTO (p, IPPROTO_SCTP);
- DecodeSCTP(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeSCTP(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
return TM_ECODE_OK;
case IPPROTO_IPIP:
IPV6_SET_L4PROTO(p, IPPROTO_IPIP);
- DecodeIPv4inIPv6(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeIPv4inIPv6(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
return TM_ECODE_OK;
case IPPROTO_IPV6:
- DecodeIP6inIP6(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeIP6inIP6(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
return TM_ECODE_OK;
case IPPROTO_GRE:
- DecodeGRE(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeGRE(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
break;
case IPPROTO_FRAGMENT:
case IPPROTO_HOPOPTS:
case IPPROTO_MH:
case IPPROTO_HIP:
case IPPROTO_SHIM6:
- DecodeIPV6ExtHdrs(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p), pq);
+ DecodeIPV6ExtHdrs(tv, dtv, p, pkt + IPV6_HEADER_LEN, IPV6_GET_PLEN(p));
break;
case IPPROTO_ICMP:
ENGINE_SET_EVENT(p,IPV6_WITH_ICMPV4);
/* Pass to defragger if a fragment. */
if (IPV6_EXTHDR_ISSET_FH(p)) {
- Packet *rp = Defrag(tv, dtv, p, pq);
+ Packet *rp = Defrag(tv, dtv, p);
if (rp != NULL) {
- PacketEnqueue(pq,rp);
+ PacketEnqueueNoLock(&tv->decode_pq,rp);
}
}
ThreadVars tv;
DecodeThreadVars dtv;
int result = 0;
- PacketQueue pq;
FlowInitConfig(FLOW_QUIET);
DefragInit();
- memset(&pq, 0, sizeof(PacketQueue));
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
PacketCopyData(p1, raw_frag1, sizeof(raw_frag1));
PacketCopyData(p2, raw_frag2, sizeof(raw_frag2));
- DecodeIPV6(&tv, &dtv, p1, GET_PKT_DATA(p1), GET_PKT_LEN(p1), &pq);
+ DecodeIPV6(&tv, &dtv, p1, GET_PKT_DATA(p1), GET_PKT_LEN(p1));
if (!(IPV6_EXTHDR_ISSET_FH(p1))) {
printf("ipv6 frag header not detected: ");
goto end;
}
- DecodeIPV6(&tv, &dtv, p2, GET_PKT_DATA(p2), GET_PKT_LEN(p2), &pq);
+ DecodeIPV6(&tv, &dtv, p2, GET_PKT_DATA(p2), GET_PKT_LEN(p2));
if (!(IPV6_EXTHDR_ISSET_FH(p2))) {
printf("ipv6 frag header not detected: ");
goto end;
}
- if (pq.len != 1) {
+ if (tv.decode_pq.len != 1) {
printf("no reassembled packet: ");
goto end;
}
PACKET_RECYCLE(p2);
SCFree(p1);
SCFree(p2);
- pkt = PacketDequeue(&pq);
+ pkt = PacketDequeueNoLock(&tv.decode_pq);
while (pkt != NULL) {
PACKET_RECYCLE(pkt);
SCFree(pkt);
- pkt = PacketDequeue(&pq);
+ pkt = PacketDequeueNoLock(&tv.decode_pq);
}
DefragDestroy();
FlowShutdown();
FAIL_IF(unlikely(p1 == NULL));
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
FlowInitConfig(FLOW_QUIET);
- memset(&pq, 0, sizeof(PacketQueue));
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
PacketCopyData(p1, raw_pkt1, sizeof(raw_pkt1));
- DecodeIPV6(&tv, &dtv, p1, GET_PKT_DATA(p1), GET_PKT_LEN(p1), &pq);
+ DecodeIPV6(&tv, &dtv, p1, GET_PKT_DATA(p1), GET_PKT_LEN(p1));
FAIL_IF (!(IPV6_EXTHDR_ISSET_RH(p1)));
FAIL_IF (p1->ip6eh.rh_type != 0);
FAIL_IF(unlikely(p1 == NULL));
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
FlowInitConfig(FLOW_QUIET);
- memset(&pq, 0, sizeof(PacketQueue));
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
PacketCopyData(p1, raw_pkt1, sizeof(raw_pkt1));
- DecodeIPV6(&tv, &dtv, p1, GET_PKT_DATA(p1), GET_PKT_LEN(p1), &pq);
+ DecodeIPV6(&tv, &dtv, p1, GET_PKT_DATA(p1), GET_PKT_LEN(p1));
FAIL_IF (!(ENGINE_ISSET_EVENT(p1, IPV6_HOPOPTS_UNKNOWN_OPT)));
#define MPLS_PROTO_IPV6 6
int DecodeMPLS(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
uint32_t shim;
int label;
if (len > USHRT_MAX) {
return TM_ECODE_FAILED;
}
- return DecodeIPV4(tv, dtv, p, pkt, len, pq);
+ return DecodeIPV4(tv, dtv, p, pkt, len);
}
else if (label == MPLS_LABEL_ROUTER_ALERT) {
/* Not valid at the bottom of the stack. */
if (len > USHRT_MAX) {
return TM_ECODE_FAILED;
}
- return DecodeIPV6(tv, dtv, p, pkt, len, pq);
+ return DecodeIPV6(tv, dtv, p, pkt, len);
}
else if (label == MPLS_LABEL_NULL) {
/* Shouldn't appear on the wire. */
if (len > USHRT_MAX) {
return TM_ECODE_FAILED;
}
- DecodeIPV4(tv, dtv, p, pkt, len, pq);
+ DecodeIPV4(tv, dtv, p, pkt, len);
break;
case MPLS_PROTO_IPV6:
if (len > USHRT_MAX) {
return TM_ECODE_FAILED;
}
- DecodeIPV6(tv, dtv, p, pkt, len, pq);
+ DecodeIPV6(tv, dtv, p, pkt, len);
break;
case MPLS_PROTO_ETHERNET_PW:
- DecodeEthernet(tv, dtv, p, pkt + MPLS_PW_LEN, len - MPLS_PW_LEN,
- pq);
+ DecodeEthernet(tv, dtv, p, pkt + MPLS_PW_LEN, len - MPLS_PW_LEN);
break;
default:
ENGINE_SET_INVALID_EVENT(p, MPLS_UNKNOWN_PAYLOAD_TYPE);
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt), NULL);
+ DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt));
if (!ENGINE_ISSET_EVENT(p, MPLS_HEADER_TOO_SMALL)) {
ret = 0;
Packet *p0 = SCCalloc(1, SIZE_OF_PACKET);
memset(p0, 0, SIZE_OF_PACKET);
uint8_t pkt0[] = { 0x00, 0x01, 0x51, 0xff };
- DecodeMPLS(&tv, &dtv, p0, pkt0, sizeof(pkt0), NULL);
+ DecodeMPLS(&tv, &dtv, p0, pkt0, sizeof(pkt0));
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p0, MPLS_PKT_TOO_SMALL));
SCFree(p0);
Packet *p1 = SCCalloc(1, SIZE_OF_PACKET);
FAIL_IF_NULL(p1);
uint8_t pkt1[] = { 0x00, 0x01, 0x51, 0xff, 0x45 };
- DecodeMPLS(&tv, &dtv, p1, pkt1, sizeof(pkt1), NULL);
+ DecodeMPLS(&tv, &dtv, p1, pkt1, sizeof(pkt1));
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p1, MPLS_PKT_TOO_SMALL));
SCFree(p1);
Packet *p2 = SCCalloc(1, SIZE_OF_PACKET);
FAIL_IF_NULL(p2);
uint8_t pkt2[] = { 0x00, 0x01, 0x51, 0xff, 0x45, 0x01 };
- DecodeMPLS(&tv, &dtv, p2, pkt2, sizeof(pkt2), NULL);
+ DecodeMPLS(&tv, &dtv, p2, pkt2, sizeof(pkt2));
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p2, MPLS_PKT_TOO_SMALL));
SCFree(p2);
Packet *p3 = SCCalloc(1, SIZE_OF_PACKET);
FAIL_IF_NULL(p3);
uint8_t pkt3[] = { 0x00, 0x01, 0x51, 0xff, 0x45, 0x01, 0x02 };
- DecodeMPLS(&tv, &dtv, p3, pkt3, sizeof(pkt3), NULL);
+ DecodeMPLS(&tv, &dtv, p3, pkt3, sizeof(pkt3));
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p3, MPLS_PKT_TOO_SMALL));
SCFree(p3);
Packet *p4 = SCCalloc(1, SIZE_OF_PACKET);
FAIL_IF_NULL(p4);
uint8_t pkt4[] = { 0x00, 0x01, 0x51, 0xff, 0x45, 0x01, 0x02, 0x03 };
- DecodeMPLS(&tv, &dtv, p4, pkt4, sizeof(pkt4), NULL);
+ DecodeMPLS(&tv, &dtv, p4, pkt4, sizeof(pkt4));
FAIL_IF(ENGINE_ISSET_EVENT(p4, MPLS_PKT_TOO_SMALL));
SCFree(p4);
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt), NULL);
+ DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt));
if (!ENGINE_ISSET_EVENT(p, MPLS_BAD_LABEL_ROUTER_ALERT)) {
ret = 0;
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt), NULL);
+ DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt));
if (!ENGINE_ISSET_EVENT(p, MPLS_BAD_LABEL_IMPLICIT_NULL)) {
ret = 0;
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt), NULL);
+ DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt));
if (!ENGINE_ISSET_EVENT(p, MPLS_BAD_LABEL_RESERVED)) {
ret = 0;
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
- DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt), NULL);
+ DecodeMPLS(&tv, &dtv, p, pkt, sizeof(pkt));
if (!ENGINE_ISSET_EVENT(p, MPLS_UNKNOWN_PAYLOAD_TYPE)) {
ret = 0;
#define HDR_SIZE 4
int DecodeNull(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_null);
switch(type) {
case AF_INET:
SCLogDebug("IPV4 Packet");
- DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p)+HDR_SIZE, GET_PKT_LEN(p)-HDR_SIZE, pq);
+ DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p)+HDR_SIZE, GET_PKT_LEN(p)-HDR_SIZE);
break;
case AF_INET6:
SCLogDebug("IPV6 Packet");
- DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p)+HDR_SIZE, GET_PKT_LEN(p)-HDR_SIZE, pq);
+ DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p)+HDR_SIZE, GET_PKT_LEN(p)-HDR_SIZE);
break;
default:
SCLogDebug("Unknown Null packet type version %" PRIu32 "", type);
#include "util-debug.h"
int DecodePPP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_ppp);
}
if (likely(IPV4_GET_RAW_VER((IPV4Hdr *)(pkt + PPP_HEADER_LEN)) == 4)) {
- return DecodeIPV4(tv, dtv, p, pkt + PPP_HEADER_LEN, len - PPP_HEADER_LEN, pq);
+ return DecodeIPV4(tv, dtv, p, pkt + PPP_HEADER_LEN, len - PPP_HEADER_LEN);
} else
return TM_ECODE_FAILED;
break;
return TM_ECODE_FAILED;
}
- return DecodeIPV4(tv, dtv, p, pkt + PPP_HEADER_LEN, len - PPP_HEADER_LEN, pq);
+ return DecodeIPV4(tv, dtv, p, pkt + PPP_HEADER_LEN, len - PPP_HEADER_LEN);
/* PPP IPv6 was not tested */
case PPP_IPV6:
return TM_ECODE_FAILED;
}
- return DecodeIPV6(tv, dtv, p, pkt + PPP_HEADER_LEN, len - PPP_HEADER_LEN, pq);
+ return DecodeIPV6(tv, dtv, p, pkt + PPP_HEADER_LEN, len - PPP_HEADER_LEN);
case PPP_VJ_COMP:
case PPP_IPX:
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp), NULL);
+ DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp));
/* Function my returns here with expected value */
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp), NULL);
+ DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp));
/* Function must returns here */
FlowInitConfig(FLOW_QUIET);
- DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp), NULL);
+ DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp));
FlowShutdown();
FlowInitConfig(FLOW_QUIET);
- DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp), NULL);
+ DecodePPP(&tv, &dtv, p, raw_ppp, sizeof(raw_ppp));
FlowShutdown();
* \brief Main decoding function for PPPOE Discovery packets
*/
int DecodePPPOEDiscovery(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_pppoe);
* \brief Main decoding function for PPPOE Session packets
*/
int DecodePPPOESession(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_pppoe);
}
if(IPV4_GET_RAW_VER((IPV4Hdr *)(pkt + PPPOE_SESSION_HEADER_LEN)) == 4) {
- DecodeIPV4(tv, dtv, p, pkt + PPPOE_SESSION_HEADER_LEN, len - PPPOE_SESSION_HEADER_LEN, pq );
+ DecodeIPV4(tv, dtv, p, pkt + PPPOE_SESSION_HEADER_LEN, len - PPPOE_SESSION_HEADER_LEN);
}
break;
return TM_ECODE_FAILED;
}
- DecodeIPV4(tv, dtv, p, pkt + PPPOE_SESSION_HEADER_LEN, len - PPPOE_SESSION_HEADER_LEN, pq );
+ DecodeIPV4(tv, dtv, p, pkt + PPPOE_SESSION_HEADER_LEN, len - PPPOE_SESSION_HEADER_LEN);
break;
/* PPP IPv6 was not tested */
return TM_ECODE_FAILED;
}
- DecodeIPV6(tv, dtv, p, pkt + PPPOE_SESSION_HEADER_LEN, len - PPPOE_SESSION_HEADER_LEN, pq );
+ DecodeIPV6(tv, dtv, p, pkt + PPPOE_SESSION_HEADER_LEN, len - PPPOE_SESSION_HEADER_LEN);
break;
default:
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodePPPOESession(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe), NULL);
+ DecodePPPOESession(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe));
if (ENGINE_ISSET_EVENT(p,PPPOE_PKT_TOO_SMALL)) {
SCFree(p);
FlowInitConfig(FLOW_QUIET);
- DecodePPPOESession(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe), NULL);
+ DecodePPPOESession(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe));
if(ENGINE_ISSET_EVENT(p,PPPOE_PKT_TOO_SMALL)) {
goto end;
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodePPPOEDiscovery(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe), NULL);
+ DecodePPPOEDiscovery(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe));
if (p->pppoedh == NULL) {
SCFree(p);
return 0;
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodePPPOEDiscovery(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe), NULL);
+ DecodePPPOEDiscovery(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe));
if(ENGINE_ISSET_EVENT(p,PPPOE_WRONG_CODE)) {
SCFree(p);
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodePPPOEDiscovery(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe), NULL);
+ DecodePPPOEDiscovery(&tv, &dtv, p, raw_pppoe, sizeof(raw_pppoe));
if(ENGINE_ISSET_EVENT(p,PPPOE_MALFORMED_TAGS)) {
SCFree(p);
int DecodeRaw(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_raw);
return TM_ECODE_FAILED;
}
SCLogDebug("IPV4 Packet");
- DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else if (IP_GET_RAW_VER(pkt) == 6) {
if (unlikely(GET_PKT_LEN(p) > USHRT_MAX)) {
return TM_ECODE_FAILED;
}
SCLogDebug("IPV6 Packet");
- DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else {
SCLogDebug("Unknown ip version %d", IP_GET_RAW_VER(pkt));
ENGINE_SET_EVENT(p,IPRAW_INVALID_IPV);
FlowInitConfig(FLOW_QUIET);
- DecodeRaw(&tv, &dtv, p, raw_ip, GET_PKT_LEN(p), NULL);
+ DecodeRaw(&tv, &dtv, p, raw_ip, GET_PKT_LEN(p));
if (p->ip6h == NULL) {
printf("expected a valid ipv6 header but it was NULL: ");
FlowShutdown();
FlowInitConfig(FLOW_QUIET);
- DecodeRaw(&tv, &dtv, p, raw_ip, GET_PKT_LEN(p), NULL);
+ DecodeRaw(&tv, &dtv, p, raw_ip, GET_PKT_LEN(p));
if (p->ip4h == NULL) {
printf("expected a valid ipv4 header but it was NULL: ");
PACKET_RECYCLE(p);
FlowInitConfig(FLOW_QUIET);
- DecodeRaw(&tv, &dtv, p, raw_ip, GET_PKT_LEN(p), NULL);
+ DecodeRaw(&tv, &dtv, p, raw_ip, GET_PKT_LEN(p));
if (!ENGINE_ISSET_EVENT(p,IPRAW_INVALID_IPV)) {
printf("expected IPRAW_INVALID_IPV to be set but it wasn't: ");
FlowShutdown();
}
int DecodeSCTP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
StatsIncr(tv, dtv->counter_sctp);
#include "util-debug.h"
int DecodeSll(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
StatsIncr(tv, dtv->counter_sll);
return TM_ECODE_FAILED;
}
DecodeIPV4(tv, dtv, p, pkt + SLL_HEADER_LEN,
- len - SLL_HEADER_LEN, pq);
+ len - SLL_HEADER_LEN);
break;
case ETHERNET_TYPE_IPV6:
if (unlikely(len > SLL_HEADER_LEN + USHRT_MAX)) {
return TM_ECODE_FAILED;
}
DecodeIPV6(tv, dtv, p, pkt + SLL_HEADER_LEN,
- len - SLL_HEADER_LEN, pq);
+ len - SLL_HEADER_LEN);
break;
case ETHERNET_TYPE_VLAN:
DecodeVLAN(tv, dtv, p, pkt + SLL_HEADER_LEN,
- len - SLL_HEADER_LEN, pq);
+ len - SLL_HEADER_LEN);
break;
default:
SCLogDebug("p %p pkt %p sll type %04x not supported", p,
}
int DecodeTCP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
StatsIncr(tv, dtv->counter_tcp);
FlowInitConfig(FLOW_QUIET);
- DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp), NULL);
+ DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp));
if (p->tcph == NULL) {
printf("tcp packet decode failed: ");
p->ip4h = &ip4h;
FlowInitConfig(FLOW_QUIET);
- DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp), NULL);
+ DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp));
if (p->tcph == NULL) {
printf("tcp packet decode failed: ");
p->ip4h = &ip4h;
FlowInitConfig(FLOW_QUIET);
- DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp), NULL);
+ DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp));
if (p->tcph == NULL) {
printf("tcp packet decode failed: ");
p->ip4h = &ip4h;
FlowInitConfig(FLOW_QUIET);
- DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp), NULL);
+ DecodeTCP(&tv, &dtv, p, raw_tcp, sizeof(raw_tcp));
if (p->tcph == NULL) {
printf("tcp packet decode failed: ");
*/
int DecodeTEMPLATE(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
/* TODO add counter for your type of packet to DecodeThreadVars,
* and register it in DecodeRegisterPerfCounters */
*/
/* invoke the next decoder on the remainder of the data */
- return DecodeUDP(tv, dtv, p, (uint8_t *)pkt + hdr_len, len - hdr_len, pq);
+ return DecodeUDP(tv, dtv, p, (uint8_t *)pkt + hdr_len, len - hdr_len);
} else {
//ENGINE_SET_EVENT(p,TEMPLATE_UNSUPPORTED_PROTOCOL);
return TM_ECODE_FAILED;
* \retval TM_ECODE_FAILED if packet is not a Teredo packet, TM_ECODE_OK if it is
*/
int DecodeTeredo(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
if (!g_teredo_enabled)
return TM_ECODE_FAILED;
if (len == IPV6_HEADER_LEN +
IPV6_GET_RAW_PLEN(thdr) + (start - pkt)) {
- if (pq != NULL) {
- int blen = len - (start - pkt);
- /* spawn off tunnel packet */
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, start, blen,
- DECODE_TUNNEL_IPV6_TEREDO, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_TEREDO);
- /* add the tp to the packet queue. */
- PacketEnqueue(pq,tp);
- StatsIncr(tv, dtv->counter_teredo);
- return TM_ECODE_OK;
- }
+ int blen = len - (start - pkt);
+ /* spawn off tunnel packet */
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, start, blen,
+ DECODE_TUNNEL_IPV6_TEREDO);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_TEREDO);
+ /* add the tp to the packet queue. */
+ PacketEnqueueNoLock(&tv->decode_pq,tp);
+ StatsIncr(tv, dtv->counter_teredo);
+ return TM_ECODE_OK;
}
}
return TM_ECODE_FAILED;
#define __DECODE_TEREDO_H__
int DecodeTeredo(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq);
+ const uint8_t *pkt, uint16_t len);
void DecodeTeredoConfig(void);
#endif
}
int DecodeUDP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
StatsIncr(tv, dtv->counter_udp);
SCLogDebug("UDP sp: %" PRIu32 " -> dp: %" PRIu32 " - HLEN: %" PRIu32 " LEN: %" PRIu32 "",
UDP_GET_SRC_PORT(p), UDP_GET_DST_PORT(p), UDP_HEADER_LEN, p->payload_len);
- if (unlikely(DecodeTeredo(tv, dtv, p, p->payload, p->payload_len, pq) == TM_ECODE_OK)) {
+ if (unlikely(DecodeTeredo(tv, dtv, p, p->payload, p->payload_len) == TM_ECODE_OK)) {
/* Here we have a Teredo packet and don't need to handle app
* layer */
FlowSetupPacket(p);
/* Handle VXLAN if configured */
if (DecodeVXLANEnabledForPort(p->sp, p->dp) &&
- unlikely(DecodeVXLAN(tv, dtv, p, p->payload, p->payload_len, pq) == TM_ECODE_OK)) {
+ unlikely(DecodeVXLAN(tv, dtv, p, p->payload, p->payload_len) == TM_ECODE_OK)) {
/* Here we have a VXLAN packet and don't need to handle app
* layer */
FlowSetupPacket(p);
#include "host.h"
static int DecodeIEEE8021ah(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq);
+ const uint8_t *pkt, uint16_t len);
/**
* \internal
*
*/
int DecodeVLAN(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
uint32_t proto;
}
DecodeIPV4(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
break;
case ETHERNET_TYPE_IPV6:
if (unlikely(len > VLAN_HEADER_LEN + USHRT_MAX)) {
return TM_ECODE_FAILED;
}
DecodeIPV6(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
break;
case ETHERNET_TYPE_PPPOE_SESS:
DecodePPPOESession(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
break;
case ETHERNET_TYPE_PPPOE_DISC:
DecodePPPOEDiscovery(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
break;
case ETHERNET_TYPE_VLAN:
case ETHERNET_TYPE_8021AD:
return TM_ECODE_OK;
} else {
DecodeVLAN(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
}
break;
case ETHERNET_TYPE_8021AH:
DecodeIEEE8021ah(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
break;
case ETHERNET_TYPE_ARP:
break;
case ETHERNET_TYPE_MPLS_UNICAST:
case ETHERNET_TYPE_MPLS_MULTICAST:
DecodeMPLS(tv, dtv, p, pkt + VLAN_HEADER_LEN,
- len - VLAN_HEADER_LEN, pq);
+ len - VLAN_HEADER_LEN);
break;
default:
SCLogDebug("unknown VLAN type: %" PRIx32 "", proto);
#define IEEE8021AH_HEADER_LEN sizeof(IEEE8021ahHdr)
static int DecodeIEEE8021ah(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint16_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint16_t len)
{
StatsIncr(tv, dtv->counter_ieee8021ah);
case ETHERNET_TYPE_VLAN:
case ETHERNET_TYPE_8021QINQ: {
DecodeVLAN(tv, dtv, p, pkt + IEEE8021AH_HEADER_LEN,
- len - IEEE8021AH_HEADER_LEN, pq);
+ len - IEEE8021AH_HEADER_LEN);
break;
}
}
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodeVLAN(&tv, &dtv, p, raw_vlan, sizeof(raw_vlan), NULL);
+ DecodeVLAN(&tv, &dtv, p, raw_vlan, sizeof(raw_vlan));
if(ENGINE_ISSET_EVENT(p,VLAN_HEADER_TOO_SMALL)) {
SCFree(p);
memset(&tv, 0, sizeof(ThreadVars));
memset(&dtv, 0, sizeof(DecodeThreadVars));
- DecodeVLAN(&tv, &dtv, p, raw_vlan, sizeof(raw_vlan), NULL);
+ DecodeVLAN(&tv, &dtv, p, raw_vlan, sizeof(raw_vlan));
if(ENGINE_ISSET_EVENT(p,VLAN_UNKNOWN_TYPE)) {
FlowInitConfig(FLOW_QUIET);
- DecodeVLAN(&tv, &dtv, p, raw_vlan, sizeof(raw_vlan), NULL);
+ DecodeVLAN(&tv, &dtv, p, raw_vlan, sizeof(raw_vlan));
if(p->vlan_id[0] == 0) {
* \param len length in bytes of pkt
*/
int DecodeVXLAN(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len)
{
if (unlikely(!g_vxlan_enabled))
return TM_ECODE_FAILED;
case ETHERNET_TYPE_ARP:
SCLogDebug("VXLAN found ARP");
break;
- case ETHERNET_TYPE_IP:
+ case ETHERNET_TYPE_IP: {
SCLogDebug("VXLAN found IPv4");
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN,
- len - (VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN), DECODE_TUNNEL_IPV4, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_VXLAN);
- PacketEnqueue(pq, tp);
- }
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN,
+ len - (VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN), DECODE_TUNNEL_IPV4);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_VXLAN);
+ PacketEnqueueNoLock(&tv->decode_pq, tp);
}
break;
- case ETHERNET_TYPE_IPV6:
+ }
+ case ETHERNET_TYPE_IPV6: {
SCLogDebug("VXLAN found IPv6");
- if (pq != NULL) {
- Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN,
- len - (VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN), DECODE_TUNNEL_IPV6, pq);
- if (tp != NULL) {
- PKT_SET_SRC(tp, PKT_SRC_DECODER_VXLAN);
- PacketEnqueue(pq, tp);
- }
+ Packet *tp = PacketTunnelPktSetup(tv, dtv, p, pkt + VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN,
+ len - (VXLAN_HEADER_LEN + ETHERNET_HEADER_LEN), DECODE_TUNNEL_IPV6);
+ if (tp != NULL) {
+ PKT_SET_SRC(tp, PKT_SRC_DECODER_VXLAN);
+ PacketEnqueueNoLock(&tv->decode_pq, tp);
}
break;
+ }
default:
SCLogDebug("VXLAN found no known Ethertype - only checks for IPv4, IPv6, ARP");
/* ENGINE_SET_INVALID_EVENT(p, VXLAN_UNKNOWN_PAYLOAD_TYPE);*/
FAIL_IF_NULL(p);
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
DecodeVXLANConfigPorts("4789");
- memset(&pq, 0, sizeof(PacketQueue));
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
memset(&dtv, 0, sizeof(DecodeThreadVars));
FlowInitConfig(FLOW_QUIET);
- DecodeUDP(&tv, &dtv, p, raw_vxlan, sizeof(raw_vxlan), &pq);
+ DecodeUDP(&tv, &dtv, p, raw_vxlan, sizeof(raw_vxlan));
FAIL_IF(p->udph == NULL);
- FAIL_IF(pq.top == NULL);
- Packet *tp = PacketDequeue(&pq);
+ FAIL_IF(tv.decode_pq.top == NULL);
+ Packet *tp = PacketDequeueNoLock(&tv.decode_pq);
FAIL_IF(tp->udph == NULL);
FAIL_IF_NOT(tp->sp == 53);
FAIL_IF_NULL(p);
ThreadVars tv;
DecodeThreadVars dtv;
- PacketQueue pq;
DecodeVXLANConfigPorts("1");
- memset(&pq, 0, sizeof(PacketQueue));
memset(&tv, 0, sizeof(ThreadVars));
memset(p, 0, SIZE_OF_PACKET);
memset(&dtv, 0, sizeof(DecodeThreadVars));
FlowInitConfig(FLOW_QUIET);
- DecodeUDP(&tv, &dtv, p, raw_vxlan, sizeof(raw_vxlan), &pq);
+ DecodeUDP(&tv, &dtv, p, raw_vxlan, sizeof(raw_vxlan));
FAIL_IF(p->udph == NULL);
- FAIL_IF(pq.top != NULL);
+ FAIL_IF(tv.decode_pq.top != NULL);
DecodeVXLANConfigPorts("4789"); /* reset */
FlowShutdown();
extern bool stats_stream_events;
int DecodeTunnel(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq, enum DecodeTunnelProto proto)
+ const uint8_t *pkt, uint32_t len, enum DecodeTunnelProto proto)
{
switch (proto) {
case DECODE_TUNNEL_PPP:
- return DecodePPP(tv, dtv, p, pkt, len, pq);
+ return DecodePPP(tv, dtv, p, pkt, len);
case DECODE_TUNNEL_IPV4:
- return DecodeIPV4(tv, dtv, p, pkt, len, pq);
+ return DecodeIPV4(tv, dtv, p, pkt, len);
case DECODE_TUNNEL_IPV6:
case DECODE_TUNNEL_IPV6_TEREDO:
- return DecodeIPV6(tv, dtv, p, pkt, len, pq);
+ return DecodeIPV6(tv, dtv, p, pkt, len);
case DECODE_TUNNEL_VLAN:
- return DecodeVLAN(tv, dtv, p, pkt, len, pq);
+ return DecodeVLAN(tv, dtv, p, pkt, len);
case DECODE_TUNNEL_ETHERNET:
- return DecodeEthernet(tv, dtv, p, pkt, len, pq);
+ return DecodeEthernet(tv, dtv, p, pkt, len);
case DECODE_TUNNEL_ERSPAN:
- return DecodeERSPAN(tv, dtv, p, pkt, len, pq);
+ return DecodeERSPAN(tv, dtv, p, pkt, len);
default:
SCLogDebug("FIXME: DecodeTunnel: protocol %" PRIu32 " not supported.", proto);
break;
* \retval p the pseudo packet or NULL if out of memory
*/
Packet *PacketTunnelPktSetup(ThreadVars *tv, DecodeThreadVars *dtv, Packet *parent,
- const uint8_t *pkt, uint32_t len, enum DecodeTunnelProto proto,
- PacketQueue *pq)
+ const uint8_t *pkt, uint32_t len, enum DecodeTunnelProto proto)
{
int ret;
SET_TUNNEL_PKT(p);
ret = DecodeTunnel(tv, dtv, p, GET_PKT_DATA(p),
- GET_PKT_LEN(p), pq, proto);
+ GET_PKT_LEN(p), proto);
if (unlikely(ret != TM_ECODE_OK) ||
(proto == DECODE_TUNNEL_IPV6_TEREDO && (p->flags & PKT_IS_INVALID)))
uint32_t default_packet_size;
#define SIZE_OF_PACKET (default_packet_size + sizeof(Packet))
-/** \brief simple fifo queue for packets
- *
- * \note PacketQueueNoLock and PacketQueue need to keep identical
- * layouts except for the mutex_q and cond_q fields.
- */
-typedef struct PacketQueueNoLock_ {
- Packet *top;
- Packet *bot;
- uint32_t len;
-#ifdef DBG_PERF
- uint32_t dbg_maxlen;
-#endif /* DBG_PERF */
-} PacketQueueNoLock;
-
-/** \brief simple fifo queue for packets with mutex and cond
- * Calling the mutex or triggering the cond is responsibility of the caller
- *
- * \note PacketQueueNoLock and PacketQueue need to keep identical
- * layouts except for the mutex_q and cond_q fields.
- */
-typedef struct PacketQueue_ {
- Packet *top;
- Packet *bot;
- uint32_t len;
-#ifdef DBG_PERF
- uint32_t dbg_maxlen;
-#endif /* DBG_PERF */
- SCMutex mutex_q;
- SCCondT cond_q;
-} PacketQueue;
-
/** \brief Structure to hold thread specific data for all decode modules */
typedef struct DecodeThreadVars_
{
};
Packet *PacketTunnelPktSetup(ThreadVars *tv, DecodeThreadVars *dtv, Packet *parent,
- const uint8_t *pkt, uint32_t len, enum DecodeTunnelProto proto, PacketQueue *pq);
+ const uint8_t *pkt, uint32_t len, enum DecodeTunnelProto proto);
Packet *PacketDefragPktSetup(Packet *parent, const uint8_t *pkt, uint32_t len, uint8_t proto);
void PacketDefragPktSetupParent(Packet *parent);
void DecodeRegisterPerfCounters(DecodeThreadVars *, ThreadVars *);
const DecodeThreadVars *dtv, const Packet *p);
/* decoder functions */
-int DecodeEthernet(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeSll(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodePPP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodePPPOESession(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodePPPOEDiscovery(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeTunnel(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *, enum DecodeTunnelProto) __attribute__ ((warn_unused_result));
-int DecodeNull(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeRaw(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeIPV4(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t, PacketQueue *);
-int DecodeIPV6(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t, PacketQueue *);
-int DecodeICMPV4(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeICMPV6(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeTCP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t, PacketQueue *);
-int DecodeUDP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t, PacketQueue *);
-int DecodeSCTP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t, PacketQueue *);
-int DecodeGRE(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeVLAN(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeVXLAN(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeMPLS(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeERSPAN(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
-int DecodeTEMPLATE(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, PacketQueue *);
+int DecodeEthernet(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeSll(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodePPP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodePPPOESession(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodePPPOEDiscovery(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeTunnel(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t, enum DecodeTunnelProto) __attribute__ ((warn_unused_result));
+int DecodeNull(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeRaw(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeIPV4(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t);
+int DecodeIPV6(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t);
+int DecodeICMPV4(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeICMPV6(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeTCP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t);
+int DecodeUDP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t);
+int DecodeSCTP(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint16_t);
+int DecodeGRE(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeVLAN(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeVXLAN(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeMPLS(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeERSPAN(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
+int DecodeTEMPLATE(ThreadVars *, DecodeThreadVars *, Packet *, const uint8_t *, uint32_t);
#ifdef UNITTESTS
void DecodeIPV6FragHeader(Packet *p, const uint8_t *pkt,
void AddressDebugPrint(Address *);
typedef int (*DecoderFunc)(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq);
+ const uint8_t *pkt, uint32_t len);
#ifdef AFLFUZZ_DECODER
int AFLDecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq);
+ const uint8_t *pkt, uint32_t len);
int AFLDecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
- const uint8_t *pkt, uint32_t len, PacketQueue *pq);
+ const uint8_t *pkt, uint32_t len);
int DecoderParseDataFromFile(char *filename, DecoderFunc Decoder);
int DecoderParseDataFromFileSerie(char *fileprefix, DecoderFunc Decoder);
#endif
* \todo Allocate packet buffers from a pool.
*/
static Packet *
-DefragInsertFrag(ThreadVars *tv, DecodeThreadVars *dtv, DefragTracker *tracker, Packet *p, PacketQueue *pq)
+DefragInsertFrag(ThreadVars *tv, DecodeThreadVars *dtv, DefragTracker *tracker, Packet *p)
{
Packet *r = NULL;
int ltrim = 0;
r = Defrag4Reassemble(tv, tracker, p);
if (r != NULL && tv != NULL && dtv != NULL) {
StatsIncr(tv, dtv->counter_defrag_ipv4_reassembled);
- if (pq && DecodeIPV4(tv, dtv, r, (void *)r->ip4h,
- IPV4_GET_IPLEN(r), pq) != TM_ECODE_OK) {
+ if (DecodeIPV4(tv, dtv, r, (void *)r->ip4h,
+ IPV4_GET_IPLEN(r)) != TM_ECODE_OK) {
UNSET_TUNNEL_PKT(r);
r->root = NULL;
r = Defrag6Reassemble(tv, tracker, p);
if (r != NULL && tv != NULL && dtv != NULL) {
StatsIncr(tv, dtv->counter_defrag_ipv6_reassembled);
- if (pq && DecodeIPV6(tv, dtv, r, (uint8_t *)r->ip6h,
- IPV6_GET_PLEN(r) + IPV6_HEADER_LEN,
- pq) != TM_ECODE_OK) {
+ if (DecodeIPV6(tv, dtv, r, (uint8_t *)r->ip6h,
+ IPV6_GET_PLEN(r) + IPV6_HEADER_LEN)
+ != TM_ECODE_OK) {
UNSET_TUNNEL_PKT(r);
r->root = NULL;
* NULL is returned.
*/
Packet *
-Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, PacketQueue *pq)
+Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p)
{
uint16_t frag_offset;
uint8_t more_frags;
if (tracker == NULL)
return NULL;
- Packet *rp = DefragInsertFrag(tv, dtv, tracker, p, pq);
+ Packet *rp = DefragInsertFrag(tv, dtv, tracker, p);
DefragTrackerRelease(tracker);
return rp;
p3 = BuildTestPacket(IPPROTO_ICMP, id, 2, 0, 'C', 3);
FAIL_IF_NULL(p3);
- FAIL_IF(Defrag(NULL, NULL, p1, NULL) != NULL);
- FAIL_IF(Defrag(NULL, NULL, p2, NULL) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p1) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p2) != NULL);
- reassembled = Defrag(NULL, NULL, p3, NULL);
+ reassembled = Defrag(NULL, NULL, p3);
FAIL_IF_NULL(reassembled);
FAIL_IF(IPV4_GET_HLEN(reassembled) != 20);
p3 = BuildTestPacket(IPPROTO_ICMP, id, 2, 0, 'C', 3);
FAIL_IF_NULL(p3);
- FAIL_IF(Defrag(NULL, NULL, p3, NULL) != NULL);
- FAIL_IF(Defrag(NULL, NULL, p2, NULL) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p3) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p2) != NULL);
- reassembled = Defrag(NULL, NULL, p1, NULL);
+ reassembled = Defrag(NULL, NULL, p1);
FAIL_IF_NULL(reassembled);
FAIL_IF(IPV4_GET_HLEN(reassembled) != 20);
p3 = IPV6BuildTestPacket(IPPROTO_ICMPV6, id, 2, 0, 'C', 3);
FAIL_IF_NULL(p3);
- FAIL_IF(Defrag(NULL, NULL, p1, NULL) != NULL);
- FAIL_IF(Defrag(NULL, NULL, p2, NULL) != NULL);
- reassembled = Defrag(NULL, NULL, p3, NULL);
+ FAIL_IF(Defrag(NULL, NULL, p1) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p2) != NULL);
+ reassembled = Defrag(NULL, NULL, p3);
FAIL_IF_NULL(reassembled);
FAIL_IF(IPV6_GET_PLEN(reassembled) != 19);
p3 = IPV6BuildTestPacket(IPPROTO_ICMPV6, id, 2, 0, 'C', 3);
FAIL_IF_NULL(p3);
- FAIL_IF(Defrag(NULL, NULL, p3, NULL) != NULL);
- FAIL_IF(Defrag(NULL, NULL, p2, NULL) != NULL);
- reassembled = Defrag(NULL, NULL, p1, NULL);
+ FAIL_IF(Defrag(NULL, NULL, p3) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p2) != NULL);
+ reassembled = Defrag(NULL, NULL, p1);
FAIL_IF_NULL(reassembled);
/* 40 bytes in we should find 8 bytes of A. */
/* Send all but the last. */
for (i = 0; i < 9; i++) {
- Packet *tp = Defrag(NULL, NULL, packets[i], NULL);
+ Packet *tp = Defrag(NULL, NULL, packets[i]);
FAIL_IF_NOT_NULL(tp);
FAIL_IF(ENGINE_ISSET_EVENT(packets[i], IPV4_FRAG_OVERLAP));
}
int overlap = 0;
for (; i < 16; i++) {
- Packet *tp = Defrag(NULL, NULL, packets[i], NULL);
+ Packet *tp = Defrag(NULL, NULL, packets[i]);
FAIL_IF_NOT_NULL(tp);
if (ENGINE_ISSET_EVENT(packets[i], IPV4_FRAG_OVERLAP)) {
overlap++;
FAIL_IF_NOT(overlap);
/* And now the last one. */
- Packet *reassembled = Defrag(NULL, NULL, packets[16], NULL);
+ Packet *reassembled = Defrag(NULL, NULL, packets[16]);
FAIL_IF_NULL(reassembled);
FAIL_IF(IPV4_GET_HLEN(reassembled) != 20);
/* Send all but the last. */
for (i = 0; i < 9; i++) {
- Packet *tp = Defrag(NULL, NULL, packets[i], NULL);
+ Packet *tp = Defrag(NULL, NULL, packets[i]);
FAIL_IF_NOT_NULL(tp);
FAIL_IF(ENGINE_ISSET_EVENT(packets[i], IPV6_FRAG_OVERLAP));
}
int overlap = 0;
for (; i < 16; i++) {
- Packet *tp = Defrag(NULL, NULL, packets[i], NULL);
+ Packet *tp = Defrag(NULL, NULL, packets[i]);
FAIL_IF_NOT_NULL(tp);
if (ENGINE_ISSET_EVENT(packets[i], IPV6_FRAG_OVERLAP)) {
overlap++;
FAIL_IF_NOT(overlap);
/* And now the last one. */
- Packet *reassembled = Defrag(NULL, NULL, packets[16], NULL);
+ Packet *reassembled = Defrag(NULL, NULL, packets[16]);
FAIL_IF_NULL(reassembled);
FAIL_IF(memcmp(GET_PKT_DATA(reassembled) + 40, expected, expected_len) != 0);
Packet *p = BuildTestPacket(IPPROTO_ICMP,i, 0, 1, 'A' + i, 16);
FAIL_IF_NULL(p);
- Packet *tp = Defrag(NULL, NULL, p, NULL);
+ Packet *tp = Defrag(NULL, NULL, p);
SCFree(p);
FAIL_IF_NOT_NULL(tp);
}
FAIL_IF_NULL(p);
p->ts.tv_sec += (defrag_context->timeout + 1);
- Packet *tp = Defrag(NULL, NULL, p, NULL);
+ Packet *tp = Defrag(NULL, NULL, p);
FAIL_IF_NOT_NULL(tp);
DefragTracker *tracker = DefragLookupTrackerFromHash(p);
FAIL_IF_NULL(p);
/* We do not expect a packet returned. */
- FAIL_IF(Defrag(NULL, NULL, p, NULL) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p) != NULL);
/* The fragment should have been ignored so no fragments should
* have been allocated from the pool. */
FAIL_IF_NULL(p);
/* We do not expect a packet returned. */
- FAIL_IF(Defrag(NULL, NULL, p, NULL) != NULL);
+ FAIL_IF(Defrag(NULL, NULL, p) != NULL);
/* We do expect an event. */
FAIL_IF_NOT(ENGINE_ISSET_EVENT(p, IPV4_FRAG_PKT_TOO_LARGE));
FAIL_IF_NULL(p2);
/* With no VLAN IDs set, packets should re-assemble. */
- FAIL_IF((r = Defrag(NULL, NULL, p1, NULL)) != NULL);
- FAIL_IF((r = Defrag(NULL, NULL, p2, NULL)) == NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p1)) != NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p2)) == NULL);
SCFree(r);
/* With mismatched VLANs, packets should not re-assemble. */
p1->vlan_id[0] = 1;
p2->vlan_id[0] = 2;
- FAIL_IF((r = Defrag(NULL, NULL, p1, NULL)) != NULL);
- FAIL_IF((r = Defrag(NULL, NULL, p2, NULL)) != NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p1)) != NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p2)) != NULL);
SCFree(p1);
SCFree(p2);
FAIL_IF_NULL(p2);
/* With no VLAN IDs set, packets should re-assemble. */
- FAIL_IF((r = Defrag(NULL, NULL, p1, NULL)) != NULL);
- FAIL_IF((r = Defrag(NULL, NULL, p2, NULL)) == NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p1)) != NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p2)) == NULL);
SCFree(r);
/* With mismatched VLANs, packets should not re-assemble. */
p2->vlan_id[0] = 1;
p1->vlan_id[1] = 1;
p2->vlan_id[1] = 2;
- FAIL_IF((r = Defrag(NULL, NULL, p1, NULL)) != NULL);
- FAIL_IF((r = Defrag(NULL, NULL, p2, NULL)) != NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p1)) != NULL);
+ FAIL_IF((r = Defrag(NULL, NULL, p2)) != NULL);
SCFree(p1);
SCFree(p2);
Packet *p3 = BuildTestPacket(IPPROTO_ICMP, ip_id, 1, 0, 'B', 8);
FAIL_IF(p1 == NULL || p2 == NULL || p3 == NULL);
- p = Defrag(NULL, NULL, p1, NULL);
+ p = Defrag(NULL, NULL, p1);
FAIL_IF_NOT_NULL(p);
- p = Defrag(NULL, NULL, p2, NULL);
+ p = Defrag(NULL, NULL, p2);
FAIL_IF_NOT_NULL(p);
/* This should return a packet as MF=0. */
- p = Defrag(NULL, NULL, p3, NULL);
+ p = Defrag(NULL, NULL, p3);
FAIL_IF_NULL(p);
/* Expected IP length is 20 + 8 + 8 = 36 as only 2 of the
Packet *p3 = IPV6BuildTestPacket(IPPROTO_ICMPV6, ip_id, 1, 0, 'B', 8);
FAIL_IF(p1 == NULL || p2 == NULL || p3 == NULL);
- p = Defrag(NULL, NULL, p1, NULL);
+ p = Defrag(NULL, NULL, p1);
FAIL_IF_NOT_NULL(p);
- p = Defrag(NULL, NULL, p2, NULL);
+ p = Defrag(NULL, NULL, p2);
FAIL_IF_NOT_NULL(p);
/* This should return a packet as MF=0. */
- p = Defrag(NULL, NULL, p3, NULL);
+ p = Defrag(NULL, NULL, p3);
FAIL_IF_NULL(p);
/* For IPv6 the expected length is just the length of the payload
p3 = BuildTestPacket(IPPROTO_ICMP, id, 2, 0, 'C', 3);
FAIL_IF_NULL(p3);
- FAIL_IF_NOT_NULL(Defrag(NULL, NULL, p1, NULL));
- FAIL_IF_NOT_NULL(Defrag(NULL, NULL, p2, NULL));
- FAIL_IF_NOT_NULL(Defrag(NULL, NULL, p3, NULL));
+ FAIL_IF_NOT_NULL(Defrag(NULL, NULL, p1));
+ FAIL_IF_NOT_NULL(Defrag(NULL, NULL, p2));
+ FAIL_IF_NOT_NULL(Defrag(NULL, NULL, p3));
SCFree(p1);
SCFree(p2);
packets[2] = BuildTestPacket(IPPROTO_ICMP, id, 24 >> 3, 1, 'C', 48);
packets[3] = BuildTestPacket(IPPROTO_ICMP, id, 88 >> 3, 0, 'D', 14);
- Packet *r = Defrag(NULL, NULL, packets[0], NULL);
+ Packet *r = Defrag(NULL, NULL, packets[0]);
FAIL_IF_NOT_NULL(r);
- r = Defrag(NULL, NULL, packets[1], NULL);
+ r = Defrag(NULL, NULL, packets[1]);
FAIL_IF_NOT_NULL(r);
- r = Defrag(NULL, NULL, packets[2], NULL);
+ r = Defrag(NULL, NULL, packets[2]);
FAIL_IF_NOT_NULL(r);
- r = Defrag(NULL, NULL, packets[3], NULL);
+ r = Defrag(NULL, NULL, packets[3]);
FAIL_IF_NULL(r);
FAIL_IF(memcmp(expected, GET_PKT_DATA(r) + 20, sizeof(expected)) != 0);
uint8_t DefragGetOsPolicy(Packet *);
void DefragTrackerFreeFrags(DefragTracker *);
-Packet *Defrag(ThreadVars *, DecodeThreadVars *, Packet *, PacketQueue *);
+Packet *Defrag(ThreadVars *, DecodeThreadVars *, Packet *);
void DefragRegisterTests(void);
#endif /* __DEFRAG_H__ */
memset(&th_v, 0, sizeof(th_v));
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, raw_eth_pkt, pktsize, NULL);
+ DecodeEthernet(&th_v, &dtv, p, raw_eth_pkt, pktsize);
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
FAIL_IF_NULL(s);
SigGroupBuild(de_ctx);
- DecodeEthernet(&tv, &dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), NULL);
+ DecodeEthernet(&tv, &dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
DetectEngineThreadCtxInit(&tv, (void *)de_ctx, (void *)&det_ctx);
p->dst.family = AF_INET6;
p->ip6h = &ip6h;
- DecodeIPV6(&tv, &dtv, p, raw_icmpv6, sizeof(raw_icmpv6), NULL);
+ DecodeIPV6(&tv, &dtv, p, raw_icmpv6, sizeof(raw_icmpv6));
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth));
de = DetectFragBitsParse("D");
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&tv, &dtv, p, raw_eth, sizeof(raw_eth));
de = DetectFragBitsParse("!D");
ip4h.s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h = &ip4h;
- DecodeICMPV4(&th_v, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4), NULL);
+ DecodeICMPV4(&th_v, &dtv, p, raw_icmpv4, sizeof(raw_icmpv4));
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
memset(&th_v, 0, sizeof(th_v));
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth));
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
memset(&th_v, 0, sizeof(th_v));
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth));
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
memset(p, 0, SIZE_OF_PACKET);
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, rawpkt1_ether, sizeof(rawpkt1_ether), NULL);
+ DecodeEthernet(&th_v, &dtv, p, rawpkt1_ether, sizeof(rawpkt1_ether));
DetectEngineThreadCtxInit(&th_v, (void *)de_ctx, (void *)&det_ctx);
/* At this point we have a list of 4 signatures. The last one
dtv.app_tctx = AppLayerGetCtxThread(&th_v);
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, GET_PKT_DATA(p), pktsize, NULL);
+ DecodeEthernet(&th_v, &dtv, p, GET_PKT_DATA(p), pktsize);
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
}
}
-static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data, PacketQueue *preq)
+static TmEcode FlowWorker(ThreadVars *tv, Packet *p, void *data)
{
FlowWorkerThreadData *fw = data;
void *detect_thread = SC_ATOMIC_GET(fw->detect_thread);
/* put these packets in the preq queue so that they are
* by the other thread modules before packet 'p'. */
- PacketEnqueue(preq, x);
+ PacketEnqueueNoLock(&tv->decode_pq, x);
}
/* handle the app layer part of the UDP packet payload */
#ifndef __PACKET_QUEUE_H__
#define __PACKET_QUEUE_H__
-#include "threads.h"
+/** \brief simple fifo queue for packets
+ *
+ * \note PacketQueueNoLock and PacketQueue need to keep identical
+ * layouts except for the mutex_q and cond_q fields.
+ */
+typedef struct PacketQueueNoLock_ {
+ struct Packet_ *top;
+ struct Packet_ *bot;
+ uint32_t len;
+#ifdef DBG_PERF
+ uint32_t dbg_maxlen;
+#endif /* DBG_PERF */
+} PacketQueueNoLock;
+
+/** \brief simple fifo queue for packets with mutex and cond
+ * Calling the mutex or triggering the cond is responsibility of the caller
+ *
+ * \note PacketQueueNoLock and PacketQueue need to keep identical
+ * layouts except for the mutex_q and cond_q fields.
+ */
+typedef struct PacketQueue_ {
+ struct Packet_ *top;
+ struct Packet_ *bot;
+ uint32_t len;
+#ifdef DBG_PERF
+ uint32_t dbg_maxlen;
+#endif /* DBG_PERF */
+ SCMutex mutex_q;
+ SCCondT cond_q;
+} PacketQueue;
+
#include "decode.h"
-void PacketEnqueueNoLock(PacketQueueNoLock *qnl, Packet *p);
-void PacketEnqueue (PacketQueue *, Packet *);
+void PacketEnqueueNoLock(PacketQueueNoLock *qnl, struct Packet_ *p);
+void PacketEnqueue (PacketQueue *, struct Packet_ *);
-Packet *PacketDequeueNoLock (PacketQueueNoLock *qnl);
-Packet *PacketDequeue (PacketQueue *);
+struct Packet_ *PacketDequeueNoLock (PacketQueueNoLock *qnl);
+struct Packet_ *PacketDequeue (PacketQueue *);
#endif /* __PACKET_QUEUE_H__ */
int RejectSendIPv4ICMP(ThreadVars *, Packet *, void *);
int RejectSendIPv6TCP(ThreadVars *, Packet *, void *);
int RejectSendIPv6ICMP(ThreadVars *, Packet *, void *);
-static TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq);
+static TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data);
void TmModuleRespondRejectRegister (void)
{
tmm_modules[TMM_RESPONDREJECT].cap_flags = 0; /* libnet is not compat with caps */
}
-static TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+static TmEcode RespondRejectFunc(ThreadVars *tv, Packet *p, void *data)
{
int ret = 0;
static TmEcode DecodeAFPThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodeAFPThreadDeinit(ThreadVars *tv, void *data);
-static TmEcode DecodeAFP(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode DecodeAFP(ThreadVars *, Packet *, void *);
static TmEcode AFPSetBPFFilter(AFPThreadVars *ptv);
static int AFPGetIfnumByDev(int fd, const char *ifname, int verbose);
/**
* \brief This function passes off to link type decoders.
*
- * DecodeAFP reads packets from the PacketQueue and passes
+ * DecodeAFP decodes packets from AF_PACKET and passes
* them off to the proper link type decoder.
*
* \param t pointer to ThreadVars
* \param p pointer to the current packet
* \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)
+TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;
/* call the decoder */
switch (p->datalink) {
case LINKTYPE_ETHERNET:
- DecodeEthernet(tv, dtv, p,GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p,GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_LINUX_SLL:
- DecodeSll(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeSll(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_PPP:
- DecodePPP(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodePPP(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_RAW:
case LINKTYPE_GRE_OVER_IP:
- DecodeRaw(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeRaw(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_NULL:
- DecodeNull(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeNull(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
default:
SCLogError(SC_ERR_DATALINK_UNIMPLEMENTED, "Error: datalink type %" PRId32 " not yet supported in module DecodeAFP", p->datalink);
TmEcode ReceiveErfDagThreadDeinit(ThreadVars *, void *);
TmEcode DecodeErfDagThreadInit(ThreadVars *, void *, void **);
TmEcode DecodeErfDagThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodeErfDag(ThreadVars *, Packet *, void *, PacketQueue *,
- PacketQueue *);
+TmEcode DecodeErfDag(ThreadVars *, Packet *, void *);
void ReceiveErfDagCloseStream(int dagfd, int stream);
/**
/**
* \brief This function passes off to link type decoders.
*
- * DecodeErfDag reads packets from the PacketQueue and passes
+ * DecodeErfDag decodes packets from DAG and passes
* them off to the proper link type decoder.
*
* \param t pointer to ThreadVars
* \param p pointer to the current packet
* \param data pointer that gets cast into PcapThreadVars for ptv
- * \param pq pointer to the current PacketQueue
*/
TmEcode
-DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+DecodeErfDag(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;
/* call the decoder */
switch(p->datalink) {
case LINKTYPE_ETHERNET:
- DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
default:
SCLogError(SC_ERR_DATALINK_UNIMPLEMENTED,
static TmEcode DecodeErfFileThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodeErfFileThreadDeinit(ThreadVars *tv, void *data);
-static TmEcode DecodeErfFile(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode DecodeErfFile(ThreadVars *, Packet *, void *);
/**
* \brief Register the ERF file receiver (reader) module.
* off to the ethernet decoder.
*/
TmEcode
-DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+DecodeErfFile(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;
/* Update counters. */
DecodeUpdatePacketCounters(tv, dtv, p);
- DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
PacketDecodeFinalize(tv, dtv, p);
/* IPFW Prototypes */
static void *IPFWGetQueue(int number);
static TmEcode ReceiveIPFWThreadInit(ThreadVars *, const void *, void **);
-static TmEcode ReceiveIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode ReceiveIPFW(ThreadVars *, Packet *, void *);
static TmEcode ReceiveIPFWLoop(ThreadVars *tv, void *data, void *slot);
static void ReceiveIPFWThreadExitStats(ThreadVars *, void *);
static TmEcode ReceiveIPFWThreadDeinit(ThreadVars *, void *);
static TmEcode IPFWSetVerdict(ThreadVars *, IPFWThreadVars *, Packet *);
-static TmEcode VerdictIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode VerdictIPFW(ThreadVars *, Packet *, void *);
static TmEcode VerdictIPFWThreadInit(ThreadVars *, const void *, void **);
static void VerdictIPFWThreadExitStats(ThreadVars *, void *);
static TmEcode VerdictIPFWThreadDeinit(ThreadVars *, void *);
static TmEcode DecodeIPFWThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodeIPFWThreadDeinit(ThreadVars *tv, void *data);
-static TmEcode DecodeIPFW(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode DecodeIPFW(ThreadVars *, Packet *, void *);
/**
* \brief Registration Function for RecieveIPFW.
* \brief This function passes off to link type decoders.
* \todo Unit tests are needed for this module.
*
- * DecodeIPFW reads packets from the PacketQueue and passes
+ * DecodeIPFW decodes packets from IPFW and passes
* them off to the proper link type decoder.
*
* \param tv pointer to ThreadVars
* \param p pointer to the current packet
* \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)
+TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data)
{
IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
IPV6Hdr *ip6h = (IPV6Hdr *)GET_PKT_DATA(p);
return TM_ECODE_FAILED;
}
SCLogDebug("DecodeIPFW ip4 processing");
- DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else if(IPV6_GET_RAW_VER(ip6h) == 6) {
if (unlikely(GET_PKT_LEN(p) > USHRT_MAX)) {
return TM_ECODE_FAILED;
}
SCLogDebug("DecodeIPFW ip6 processing");
- DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else {
/* We don't support anything besides IP packets for now, bridged packets? */
* \param tv pointer to ThreadVars
* \param p pointer to the Packet
* \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)
+TmEcode VerdictIPFW(ThreadVars *tv, Packet *p, void *data)
{
IPFWThreadVars *ptv = (IPFWThreadVars *)data;
TmEcode retval = TM_ECODE_OK;
TmEcode NapatechDecodeThreadInit(ThreadVars *, const void *, void **);
TmEcode NapatechDecodeThreadDeinit(ThreadVars *tv, void *data);
-TmEcode NapatechDecode(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode NapatechDecode(ThreadVars *, Packet *, void *);
/* These are used as the threads are exiting to get a comprehensive count of
* all the packets received and dropped.
/**
* \brief This function passes off to link type decoders.
*
- * NapatechDecode reads packets from the PacketQueue and passes
+ * NapatechDecode decodes packets from Napatech and passes
* them off to the proper link type decoder.
*
* \param t pointer to ThreadVars
* \param p pointer to the current packet
* \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)
+TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
switch (p->datalink) {
case LINKTYPE_ETHERNET:
- DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
default:
SCLogError(SC_ERR_DATALINK_UNIMPLEMENTED,
/**
* \brief This function passes off to link type decoders.
*
- * DecodeNetmap reads packets from the PacketQueue and passes
- * them off to the proper link type decoder.
- *
* \param t pointer to ThreadVars
* \param p pointer to the current packet
* \param data pointer that gets cast into NetmapThreadVars for ntv
- * \param pq pointer to the current PacketQueue
*/
-static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
/* update counters */
DecodeUpdatePacketCounters(tv, dtv, p);
- DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
PacketDecodeFinalize(tv, dtv, p);
TmEcode DecodeNFLOGThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeNFLOGThreadDeinit(ThreadVars *tv, void *data);
-TmEcode DecodeNFLOG(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodeNFLOG(ThreadVars *, Packet *, void *);
static int runmode_workers;
* \param tv pointer to ThreadVars
* \param p pointer to the current packet
* \param data pointer that gets cast into NFLOGThreadVars for ptv
- * \param pq pointer to the current PacketQueue
*
* \retval TM_ECODE_OK is always returned
*/
-TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
return TM_ECODE_FAILED;
}
SCLogDebug("IPv4 packet");
- DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else if(IPV6_GET_RAW_VER(ip6h) == 6) {
if (unlikely(GET_PKT_LEN(p) > USHRT_MAX)) {
return TM_ECODE_FAILED;
}
SCLogDebug("IPv6 packet");
- DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else {
SCLogDebug("packet unsupported by NFLOG, first byte: %02x", *GET_PKT_DATA(p));
}
static TmEcode ReceiveNFQThreadDeinit(ThreadVars *, void *);
static void ReceiveNFQThreadExitStats(ThreadVars *, void *);
-static TmEcode VerdictNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode VerdictNFQ(ThreadVars *, Packet *, void *);
static TmEcode VerdictNFQThreadInit(ThreadVars *, const void *, void **);
static TmEcode VerdictNFQThreadDeinit(ThreadVars *, void *);
-static TmEcode DecodeNFQ(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode DecodeNFQ(ThreadVars *, Packet *, void *);
static TmEcode DecodeNFQThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodeNFQThreadDeinit(ThreadVars *tv, void *data);
/**
* \brief NFQ verdict module packet entry function
*/
-TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode VerdictNFQ(ThreadVars *tv, Packet *p, void *data)
{
NFQThreadVars *ntv = (NFQThreadVars *)data;
/* update counters */
/**
* \brief Decode a packet coming from NFQ
*/
-TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data)
{
IPV4Hdr *ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
return TM_ECODE_FAILED;
}
SCLogDebug("IPv4 packet");
- DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV4(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else if (IPV6_GET_RAW_VER(ip6h) == 6) {
if (unlikely(GET_PKT_LEN(p) > USHRT_MAX)) {
return TM_ECODE_FAILED;
}
SCLogDebug("IPv6 packet");
- DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV6(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else {
SCLogDebug("packet unsupported by NFQ, first byte: %02x", *GET_PKT_DATA(p));
}
static void ReceivePcapFileThreadExitStats(ThreadVars *, void *);
static TmEcode ReceivePcapFileThreadDeinit(ThreadVars *, void *);
-static TmEcode DecodePcapFile(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode DecodePcapFile(ThreadVars *, Packet *, void *);
static TmEcode DecodePcapFileThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodePcapFileThreadDeinit(ThreadVars *tv, void *data);
static double prev_signaled_ts = 0;
-static TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+static TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;
if(ValidateLinkType(p->datalink, &decoder) == TM_ECODE_OK) {
/* call the decoder */
- decoder(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ decoder(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
#ifdef DEBUG
BUG_ON(p->pkt_src != PKT_SRC_WIRE && p->pkt_src != PKT_SRC_FFR);
static TmEcode DecodePcapThreadInit(ThreadVars *, const void *, void **);
static TmEcode DecodePcapThreadDeinit(ThreadVars *tv, void *data);
-static TmEcode DecodePcap(ThreadVars *, Packet *, void *, PacketQueue *);
+static TmEcode DecodePcap(ThreadVars *, Packet *, void *);
/** protect pcap_compile and pcap_setfilter, as they are not thread safe:
* http://seclists.org/tcpdump/2009/q1/62 */
/**
* \brief This function passes off to link type decoders.
*
- * DecodePcap reads packets from the PacketQueue and passes
+ * DecodePcap decodes packets from libpcap and passes
* them off to the proper link type decoder.
*
* \param t pointer to ThreadVars
* \param p pointer to the current packet
* \param data pointer that gets cast into PcapThreadVars for ptv
- * \param pq pointer to the current PacketQueue
*/
-static TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+static TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
DecodeThreadVars *dtv = (DecodeThreadVars *)data;
/* call the decoder */
switch(p->datalink) {
case LINKTYPE_LINUX_SLL:
- DecodeSll(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeSll(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_ETHERNET:
- DecodeEthernet(tv, dtv, p,GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p,GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_PPP:
- DecodePPP(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodePPP(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_RAW:
case LINKTYPE_GRE_OVER_IP:
- DecodeRaw(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeRaw(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
case LINKTYPE_NULL:
- DecodeNull(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeNull(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
break;
default:
SCLogError(SC_ERR_DATALINK_UNIMPLEMENTED, "Error: datalink "
TmEcode ReceivePfringThreadDeinit(ThreadVars *, void *);
TmEcode DecodePfringThreadInit(ThreadVars *, const void *, void **);
-TmEcode DecodePfring(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodePfring(ThreadVars *, Packet *, void *);
TmEcode DecodePfringThreadDeinit(ThreadVars *tv, void *data);
extern int max_pending_packets;
/**
* \brief This function passes off to link type decoders.
*
- * DecodePfring reads packets from the PacketQueue. Inside of libpcap version of
+ * DecodePfring decodes raw packets from PF_RING. Inside of libpcap version of
* PF_RING all packets are marked as a link type of ethernet so that is what we do here.
*
* \param tv pointer to ThreadVars
* \param p pointer to the current packet
* \param data pointer that gets cast into PfringThreadVars for ptv
- * \param pq pointer to the current PacketQueue
*
* \todo Verify that PF_RING only deals with ethernet traffic
*
*
* \retval TM_ECODE_OK is always returned
*/
-TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
+TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data)
{
DecodeThreadVars *dtv = (DecodeThreadVars *)data;
StatsIncr(tv, dtv->counter_vlan);
}
- DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
PacketDecodeFinalize(tv, dtv, p);
void ReceiveWinDivertThreadExitStats(ThreadVars *, void *);
/* Verdict functions */
-TmEcode VerdictWinDivert(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode VerdictWinDivert(ThreadVars *, Packet *, void *);
TmEcode VerdictWinDivertThreadInit(ThreadVars *, const void *, void **);
TmEcode VerdictWinDivertThreadDeinit(ThreadVars *, void *);
/* Decode functions */
-TmEcode DecodeWinDivert(ThreadVars *, Packet *, void *, PacketQueue *);
+TmEcode DecodeWinDivert(ThreadVars *, Packet *, void *);
TmEcode DecodeWinDivertThreadInit(ThreadVars *, const void *, void **);
TmEcode DecodeWinDivertThreadDeinit(ThreadVars *, void *);
/**
* \brief WinDivert verdict module packet entry function
*/
-TmEcode VerdictWinDivert(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq);
+TmEcode VerdictWinDivert(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
* 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)
+TmEcode DecodeWinDivert(ThreadVars *tv, Packet *p, void *data)
{
SCEnter();
if (IPV4_GET_RAW_VER(ip4h) == 4) {
SCLogDebug("IPv4 packet");
- DecodeIPV4(tv, d_tv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV4(tv, d_tv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else if (IPV6_GET_RAW_VER(ip6h) == 6) {
SCLogDebug("IPv6 packet");
- DecodeIPV6(tv, d_tv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
+ DecodeIPV6(tv, d_tv, p, GET_PKT_DATA(p), GET_PKT_LEN(p));
} else {
SCLogDebug("packet unsupported by WinDivert, first byte: %02x",
*GET_PKT_DATA(p));
memset(&th_v, 0, sizeof(th_v));
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth));
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
memset(&th_v, 0, sizeof(th_v));
FlowInitConfig(FLOW_QUIET);
- DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth), NULL);
+ DecodeEthernet(&th_v, &dtv, p, raw_eth, sizeof(raw_eth));
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (unlikely(p1 == NULL))
return 0;
memset(p1, 0, SIZE_OF_PACKET);
- DecodeEthernet(&th_v, &dtv, p1, rawpkt1, sizeof(rawpkt1), NULL);
+ DecodeEthernet(&th_v, &dtv, p1, rawpkt1, sizeof(rawpkt1));
SigMatchSignatures(&th_v, de_ctx, det_ctx, p1);
if (!(PacketAlertCheck(p1, 556))) {
printf("failed to match on packet 1: ");
if (unlikely(p2 == NULL))
return 0;
memset(p2, 0, SIZE_OF_PACKET);
- DecodeEthernet(&th_v, &dtv, p2, rawpkt2, sizeof(rawpkt2), NULL);
+ DecodeEthernet(&th_v, &dtv, p2, rawpkt2, sizeof(rawpkt2));
SigMatchSignatures(&th_v, de_ctx, det_ctx, p2);
if (!(PacketAlertCheck(p2, 556))) {
printf("failed to match on packet 2: ");
if (unlikely(p3 == NULL))
return 0;
memset(p3, 0, SIZE_OF_PACKET);
- DecodeEthernet(&th_v, &dtv, p3, rawpkt3, sizeof(rawpkt3), NULL);
+ DecodeEthernet(&th_v, &dtv, p3, rawpkt3, sizeof(rawpkt3));
SigMatchSignatures(&th_v, de_ctx, det_ctx, p3);
if (!(PacketAlertCheck(p3, 556))) {
printf("failed to match on packet 3: ");
if (unlikely(p4 == NULL))
return 0;
memset(p4, 0, SIZE_OF_PACKET);
- DecodeEthernet(&th_v, &dtv, p4, rawpkt4, sizeof(rawpkt4), NULL);
+ DecodeEthernet(&th_v, &dtv, p4, rawpkt4, sizeof(rawpkt4));
SigMatchSignatures(&th_v, de_ctx, det_ctx, p4);
if (!(PacketAlertCheck(p4, 556))) {
printf("failed to match on packet 4: ");
#include "tm-queues.h"
#include "counters.h"
#include "threads.h"
+#include "packet-queue.h"
struct TmSlot_;
void *outctx;
void (*tmqh_out)(struct ThreadVars_ *, struct Packet_ *);
+ /** queue for decoders to temporarily store extra packets they
+ * generate. */
+ PacketQueueNoLock decode_pq;
+
/** Stream packet queue for flow time out injection. Either a pointer to the
* workers input queue or to stream_pq_local */
struct PacketQueue_ *stream_pq;
TmEcode (*ThreadDeinit)(ThreadVars *, void *);
/** the packet processing function */
- TmEcode (*Func)(ThreadVars *, Packet *, void *, PacketQueue *);
+ TmEcode (*Func)(ThreadVars *, Packet *, void *);
TmEcode (*PktAcqLoop)(ThreadVars *, void *, void *);
{
for (TmSlot *s = slot; s != NULL; s = s->slot_next) {
PACKET_PROFILING_TMM_START(p, s->tm_id);
- TmEcode r = s->SlotFunc(tv, p, SC_ATOMIC_GET(s->slot_data),
- &s->slot_pre_pq);
+ TmEcode r = s->SlotFunc(tv, p, SC_ATOMIC_GET(s->slot_data));
PACKET_PROFILING_TMM_END(p, s->tm_id);
/* handle error */
}
/* handle new packets */
- while (s->slot_pre_pq.top != NULL) {
- Packet *extra_p = PacketDequeue(&s->slot_pre_pq);
+ while (tv->decode_pq.top != NULL) {
+ Packet *extra_p = PacketDequeueNoLock(&tv->decode_pq);
if (unlikely(extra_p == NULL))
continue;
return TM_ECODE_OK;
}
-/** \internal
- * \brief check 'slot' pre_pq and thread cleanup
- * and dump detailed info about the state of the packets
- * and threads if in a unexpected state.
- */
-static void CheckSlot(const TmSlot *slot)
-{
- if (slot->slot_pre_pq.len) {
- for (Packet *xp = slot->slot_pre_pq.top; xp != NULL; xp = xp->next) {
- SCLogNotice("pre_pq: slot tm_id %u pre_pq.len %u packet src %s",
- slot->tm_id, slot->slot_pre_pq.len, PktSrcToString(xp->pkt_src));
- }
- TmThreadDumpThreads();
- abort();
- }
-}
-
#ifndef AFLFUZZ_PCAP_RUNMODE
/** \internal
}
(void)SC_ATOMIC_SET(slot->slot_data, slot_data);
}
- memset(&slot->slot_pre_pq, 0, sizeof(PacketQueue));
- SCMutexInit(&slot->slot_pre_pq.mutex_q, NULL);
/* if the flowworker module is the first, get the threads input queue */
if (slot == (TmSlot *)tv->tm_slots && (slot->tm_id == TMM_FLOWWORKER)) {
goto error;
}
}
- CheckSlot(slot);
}
tv->stream_pq = NULL;
}
(void)SC_ATOMIC_SET(slot->slot_data, slot_data);
}
- memset(&slot->slot_pre_pq, 0, sizeof(PacketQueue));
- SCMutexInit(&slot->slot_pre_pq.mutex_q, NULL);
/* if the flowworker module is the first, get the threads input queue */
if (slot == (TmSlot *)tv->tm_slots && (slot->tm_id == TMM_FLOWWORKER)) {
goto error;
}
}
-
- CheckSlot(slot);
}
tv->stream_pq = NULL;
}
(void)SC_ATOMIC_SET(s->slot_data, slot_data);
}
- memset(&s->slot_pre_pq, 0, sizeof(PacketQueue));
- SCMutexInit(&s->slot_pre_pq.mutex_q, NULL);
/* special case: we need to access the stream queue
* from the flow timeout code */
goto error;
}
}
- CheckSlot(s);
}
SCLogDebug("%s ending", tv->name);
}
(void)SC_ATOMIC_SET(s->slot_data, slot_data);
}
- memset(&s->slot_pre_pq, 0, sizeof(PacketQueue));
StatsSetupPrivate(tv);
TmModule *m = TmModuleGetById(s->tm_id);
SCLogNotice("tv %p: -> slot %p tm_id %d name %s",
tv, s, s->tm_id, m->name);
- for (Packet *xp = s->slot_pre_pq.top; xp != NULL; xp = xp->next) {
- SCLogNotice("tv %p: ==> pre_pq: slot tm_id %u pre_pq.len %u packet src %s",
- tv, s->tm_id, s->slot_pre_pq.len, PktSrcToString(xp->pkt_src));
- }
}
}
tv, tv->stream_pq_local->len, PktSrcToString(xp->pkt_src));
}
}
+ for (Packet *xp = tv->decode_pq.top; xp != NULL; xp = xp->next) {
+ SCLogNotice("tv %p: ==> decode_pq: decode_pq.len %u packet src %s",
+ tv, tv->decode_pq.len, PktSrcToString(xp->pkt_src));
+ }
TmThreadDoDumpSlots(tv);
tv = tv->next;
}
#define TM_QUEUE_NAME_MAX 16
#define TM_THREAD_NAME_MAX 16
-typedef TmEcode (*TmSlotFunc)(ThreadVars *, Packet *, void *, PacketQueue *);
+typedef TmEcode (*TmSlotFunc)(ThreadVars *, Packet *, void *);
typedef struct TmSlot_ {
/* function pointers */
SC_ATOMIC_DECLARE(void *, slot_data);
- /* queue filled by the SlotFunc with packets that will
- * be processed futher _before_ the current packet.
- * The locks in the queue are NOT used */
- PacketQueue slot_pre_pq;
-
TmEcode (*SlotThreadInit)(ThreadVars *, const void *, void **);
void (*SlotThreadExitPrintStats)(ThreadVars *, void *);
TmEcode (*SlotThreadDeinit)(ThreadVars *, void *);
uint32_t TmThreadCountThreadsByTmmFlags(uint8_t flags);
+static inline void TmThreadsCleanDecodePQ(PacketQueueNoLock *pq)
+{
+ while (1) {
+ Packet *p = PacketDequeueNoLock(pq);
+ if (unlikely(p == NULL))
+ break;
+ TmqhOutputPacketpool(NULL, p);
+ }
+}
+
static inline void TmThreadsSlotProcessPktFail(ThreadVars *tv, TmSlot *s, Packet *p)
{
if (p != NULL) {
TmqhOutputPacketpool(tv, p);
}
- TmqhReleasePacketsToPacketPool(&s->slot_pre_pq);
+ TmThreadsCleanDecodePQ(&tv->decode_pq);
if (tv->stream_pq_local) {
SCMutexLock(&tv->stream_pq_local->mutex_q);
TmqhReleasePacketsToPacketPool(tv->stream_pq_local);
SCFree(p);
return NULL;
}
- DecodeEthernet(&th_v, &dtv, p[i], raw_eth[i], pktsize[i], NULL);
+ DecodeEthernet(&th_v, &dtv, p[i], raw_eth[i], pktsize[i]);
}
return p;
}
memset(&dtv, 0, sizeof(DecodeThreadVars));
memset(&th_v, 0, sizeof(th_v));
- DecodeEthernet(&th_v, &dtv, p, raw_eth, pktsize, NULL);
+ DecodeEthernet(&th_v, &dtv, p, raw_eth, pktsize);
return p;
}
projects / thirdparty / suricata.git / commitdiff
