packet recycle: remove mutex destroy/init

This was necessary earlier when there was a memset involved.

packet recycle: do most clean up on packet reuse

Call PACKET_RELEASE_REFS from PacketPoolGetPacket() so that
we only access the large packet structure just before actually
using it. Should give better cache behaviour.

packet recycle: split macro

Split PACKET_RECYCLE into 2 parts. One part for cleanup to do before a
packet is returned to the pool, the other after it's retrieved from
the pool.

Fix decode tests calling PACKET_DO_RECYCLE instead of PACKET_RECYCLE

Update Changelog for 2.1beta1

Update Changelog for 2.0.3

Fix GRE Source Routing Header definition

The Source Routing Header had routing defined as a char* for a field
of variable size. Since that field was not being used in the code, I
removed the pointer and added a comment.

More structures that need to be marked Packed.

These structures are cast from raw packet data, so they should be packed.
The case is:

typedef struct Foo_ {
} Foo;

Foo *f = (Foo *)pkt;

Add Packed attribute on Header structures

Structures that are used to cast packet data into fields need to be packed
so that the compiler doesn't add any padding to these fields. This also helps
Tile-Gx to avoid unaligned loads because the compiler will insert code to
handle the possible unaligned load.

lua: improve configure checks

The base 'lua' library has different names on different OS' and even
Linux distro's. Instead of selecting the proper one, we now just try
all. This way no OS/distro specific knowledge about the name is needed.

alert-json: clean up flags

Make payload/packet logging code also use the flags field in
AlertJsonOutputCtx, instead of in the LogFileCtx.

json-alert: include HTTP info on the alerts

Extends the JSON alert output to include the HTTP data
at the time of the alert.

json-http: refactoring output code

Splits the output code in two public functions and permits
to call them from the alert function

Use extra data structure in json alert output
to store local configuration

stream: detect and filter out bad window updates

Reported in bug 1238 is an issue where stream reassembly can be
disrupted.

A packet that was in-window, but otherwise unexpected set the
window to a really low value, causing the next *expected* packet
to be considered out of window. This lead to missing data in the
stream reassembly.

The packet was unexpected in various ways:
- it would ack unseen traffic
- it's sequence number would not match the expected next_seq
- set a really low window, while not being a proper window update

Detection however, it greatly hampered by the fact that in case of
packet loss, quite similar packets come in. Alerting in this case
is unwanted. Ignoring/skipping packets in this case as well.

The logic used in this patch is as follows. If:

- the packet is not a window update AND
- packet seq > next_seq AND
- packet acq > next_seq (packet acks unseen data) AND
- packet shrinks window more than it's own data size
THEN set event and skip the packet in the stream engine.

So in case of a segment with no data, any window shrinking is rejected.

Bug #1238.

ipv6: fix dst/hop header option parsing

The extension header option parsing used a uint8_t internally. However
much bigger option sizes are valid.

defrag: use 'struct timeval' for timeout tracking

Until now the time out handling in defrag was done using a single
uint32_t that tracked seconds. This lead to corner cases, where
defrag trackers could be timed out a little too early.

ipv6: set event on unsupported nh

If a next header / protocol is encountered that we can't handle (yet)
set an event. Disabled the rule by default.

    decode-event:ipv6.unknown_next_header;

ipv6: more robust ipv6 exthdr handling

Skip past Shim6, HIP and Mobility header.

Detect data after 'none' header.
    decode-event:ipv6.data_after_none_header;

ipv6: detect frag header reserved field non-zero

Frag Header length field is reserved, and should be set to 0.

    decode-event:ipv6.fh_non_zero_reserved_field;

ipv6: make exthdr parsing more robust

Improve data length checks. Detect PadN option with 0 length.

ipv6: set flag on type 0 routing header

Type 0 Routing headers are deprecated per RFC 5095.

This patch sets an decode event flag that can be matched on through:
    decode-event:ipv6.rh_type_0;

ipv6 defrag: fix unfragmentable exthdr handling

Fix or rather implement handling of unfragmentable exthdrs in ipv6.
The exthdr(s) appearing before the frag header were copied into the
reassembled packet correctly, however the stripping of the frag header
did not work correctly.

Example:
The common case is a frag header directly after the ipv6 header:

[ipv6 header]->[frag header]->[icmpv6 (part1)]
[ipv6 header]->[frag header]->[icmpv6 (part2)]

This would result in:
[ipv6 header]->[icmpv6]

The ipv6 headers 'next header' setting would be updated to point to
whatever the frag header was pointing to.

This would also happen when is this case:

[ipv6 header]->[hop header]->[frag header]->[icmpv6 (part1)]
[ipv6 header]->[hop header]->[frag header]->[icmpv6 (part2)]

The result would be:
[ipv6 header]->[hop header]->[icmpv6]

However, here too the ipv6 header would have been updated to point
to what the frag header pointed at. So it would consider the hop header
as if it was an ICMPv6 header, or whatever the frag header pointed at.

The result is that packets would not be correctly parsed, and thus this
issue can lead to evasion.

This patch implements handling of the unfragmentable part. In the first
segment that is stored in the list for reassembly, this patch detects
unfragmentable headers and updates it to have the last unfragmentable
header point to the layer after the frag header.

Also, the ipv6 headers 'next hdr' is only updated if no unfragmentable
headers are used. If they are used, the original value is correct.

Reported-By: Rafael Schaefer <rschaefer@ernw.de>
Bug #1244.

packet pool: init pthread key before using it

In the packet pool code, it's critical to initialize the pthread key
before using it. Applies only to the code used if __thread isn't
supported.

packet pool: cosmetic cleanups

prscript: update URL

Buildbot server has been moved to another box.

magic: disable tests depending on magic version

Some tests depend on specific results by specific magic versions.
Disable these.

suricata: RunUnittests now return void

RunUnittests function is now a terminal function (calling exit
before leaving).

unittests: don't register app layer test

Some tests are already registered via the function
AppLayerParserRegisterProtocolUnittests. So we don't need to
egister them during runmode initialization.

Fix up mistaken style change

fixup

Enforce function coding standard

Functions should be defined as:

int foo(void)
{
}

Rather than:
int food(void) {
}

All functions where changed by a script to match this standard.

eve: add tx_id to output for alerts and events

Add tx_id field for correlating alerts and events per tx.

Update app-layer-htp.c

When keyword "boundary=" doesn't exist in the http_header, the value of r is 0 and this condition shouldn't return 0 instead 1;

Reduce reallocation in AC Tile MPM creation.

Exponentially increase the memory allocated for new states when adding new
states, then at the end resize down to the actually final size so that no space is wasted.

Add input interface's name to JSON log

pcap-log: yaml comment update

pcap-log: unify lock handling, fixes Coverity warn

*** CID 1229124:  Data race condition  (MISSING_LOCK)
/src/log-pcap.c: 363 in PcapLog()
357         {
358             return TM_ECODE_OK;
359         }
360
361         PcapLogLock(pl);
362
>>>     CID 1229124:  Data race condition  (MISSING_LOCK)
>>>     Accessing "pl->pkt_cnt" without holding lock "PcapLogData_.plog_lock". Elsewhere, "PcapLogData_.pkt_cnt" is accessed with "PcapLogData_.plog_lock" held 1 out of 2 times (1 of these accesses strongly imply that it is necessary).
363         pl->pkt_cnt++;
364         pl->h->ts.tv_sec = p->ts.tv_sec;
365         pl->h->ts.tv_usec = p->ts.tv_usec;
366         pl->h->caplen = GET_PKT_LEN(p);
367         pl->h->len = GET_PKT_LEN(p);
368         len = sizeof(*pl->h) + GET_PKT_LEN(p);

Cleanup Packet Pools when done.

Fix Packet Stacks for non-TLS Operating Systems

On non-TLS systems, check each time the Thread Local Storage
is requested and if it has not been initialized for this thread, initialize it.
The prevents not initializing the worker threads in autofp run mode.

travis-ci: use make check

This patch replaces unittest run by make check. It also install
coccinelle so we should have more test.

coccinelle: fix problem with coccinelle 1.0rc21

coccinelle 1.0rc21 has a problem with regular expression handling.
This result in a Fatal Error when test system detects an coding
error.

This patch fixes the problem by using a simple blob inside
semantic patch instead of using a regular expression to define
the function.

It also fixes add an optimization on matching suppressing a
useless <.. ..> construction.

Fixes have been suggested by Julia Lawall.

flow-recycler: support multiple instances

Use new management API to run the flow recycler.

Make number of threads configurable:

flow:
  memcap: 64mb
  hash-size: 65536
  prealloc: 10000
  emergency-recovery: 30
  managers: 2
  recyclers: 2

This sets up 2 flow recyclers.

flow-manager: support multiple instances

Use new management API to run the flow manager.

Support multiple flow managers, where each of them works with it's
own part of the flow hash.

Make number of threads configurable:

flow:
  memcap: 64mb
  hash-size: 65536
  prealloc: 10000
  emergency-recovery: 30
  managers: 2

This sets up 2 flow managers.

Handle misc tasks only in instance 1: Handle defrag hash timeout
handing, host hash timeout handling and flow spare queue updating
only from the first instance.

threads: add management API

Currently management threads do their own thread setup and handling. This
patch introduces a new way of handling management threads.

Functionality that needs to run as a management thread can now register
itself as a regular 'thread module' (TmModule), where the 'Management'
callback is registered.

flow id: quick and dirty first stab at a flow id

Add a 'flow_id' that is the same for all records produced for packets
belonging to the same flow.

This patch simply takes the flow's memory address.

flow: add flow_end_flags field, add logging

The flow end flags field is filled by the flow manager or the flow
hash (in case of forced timeout of a flow) to record the timeout
conditions in the flow:
- emergency mode
- state
- reason (timed out or forced)

Add logging to the flow logger.

flow: move FlowGetFlowState

Move FlowGetFlowState to flow-private.h so that all parts of the flow
engine can use it.

flow log: log TCP state

Log the TCP state at timeout.

flow-recycler: speed up flow-recycler shutdown

Thread was killed by the generic TmThreadKillThreads instead of
the FlowKillFlowRecyclerThread. The latter wakes the thread up, so
that shutdown is quite a bit faster.

flow: log individual tcp flags

Log the tcp flags.

netflow: log individual tcp flags

Log the tcp flags.

json: add tcp flags to json utility function

Turns a flags bitfield into a set of json bools.

netflow-json: initial version

Initial version of netflow module, a flow logger that logs each
direction in a completely separate record (line).

flow-log: log TCP flags per direction

In addition to flags for the entire session, also log out TCP flags
for both directions separately.

stream: track TCP flags per stream direction

For netflow logging track TCP flags per stream direction. As the struct
had no more space left without expanding it, the flags and wscale
fields are now compressed.

flow: init logger thread data for decoders

Initialize the output flow api thread data for the decoder threads.

decode: pass ThreadVars to DecodeThreadVarsFree

Flow output thread data deinit function which will be called from
DecodeThreadVarsFree will need it.

flow: prepare flow forced reuse logging

Most flows are marked for clean up by the flow manager, which then
passes them to the recycler. The recycler logs and cleans up. However,
under resource stress conditions, the packet threads can recycle
existing flow directly. So here the recycler has no role to play, as
the flow is immediately used.

For this reason, the packet threads need to be able to invoke the
flow logger directly.

The flow logging thread ctx will stored in the DecodeThreadVars
stucture. Therefore, this patch makes the DecodeThreadVars an argument
to FlowHandlePacket.

flow: take flow pkt & byte count out of debug

Until now the flow packet and byte counters were only available in
DEBUG mode. For logging purposes they are now available always.

flow: don't BUG_ON if no loggers are enabled

API is always called, even if no loggers are enabled. Don't abort()
in this case.

flow: clean up recycle queue at shutdown

Mostly for tests that don't start the recycler thread, make sure
all flows are cleaned up.

flow unittest: update flow manager unit test

Test now tests a different queue.

flow: track lastts in struct timeval

Track full timestamp for lastts in flows to be able to log it.

flow: track bytes per direction

Track bytes in both flow directions for logging purposes.

flow log: log start/end times

Log time of first packet (flow creation) and of the last packet.

flow-log: log TCP flags seen

Log TCP flags seen during the life time of a flow/session.

tcp: track TCP packet flags per session

For logging out in flow logging.

flow-log: log pkts, bytes

Only in DEBUG currently.

flow-json-log: stub

Stub for JSON flow logger.

flow: flow log threading setup

Set up threading for the flow logger.

flow log: call logger from recycler

Call the flow logger API from the recycler thread, so that timed
out flows are logged.

flow: output api stub

Basic output API for flow logging.

flow recycler: unix socket support

Support starting and shutting down the flow recycler thread in the
unix socket runmode.

flow recycler: shutdown

Only shut down when all flows in the recycle queue have been processed.

flow: move flow cleanup to new 'recycler'

Move Flow clean up from the flow manager to the new flow recycler.

flow: introduce FlowRecycler stub

FlowRecycler thread stub. Start/stop code.

flow: new flow queue: flow_recycle_q

This queue will be used by the FlowManager to pass timed out flows
to another thread that will do the actual cleanup.

Fix eve 'filetype' parsing

Now that we use 'filetype' instead of 'type', we should also
use 'regular' instead of 'file'.

Added fallback to make sure we stay compatible to old configs.

Fixed memory leak

Fix possible crash when logfile descriptor is invalid

Fix handling filetype for eve log

Fixed variables names in suricata.yaml.in Changed logging logic - now it's possible to enable different payload dumping modes separately Fixed bug in dumping packet without stream segments Fixed indents

Changed attribute name for printable payload

Changed variable name when dumping single packet

Add ability to encode payload in Base64

Fixed stream handling Fixed some coding style issues

Add packet and payload logging to JSON alert output

Fix engine getting stuck because of optimizations

At -O1+ in both Gcc and Clang, PacketPoolWait would optimize the
wait loop in the wrong way. Adding a compiler barrier to prevent
this optimization issue.

Remove unused variables

Fix packet pool pending stack adds

Add packets after the first as the list/stack head as well.

Fix pcap packet acquisition methods

Fix pcap packet acquisition methods passing 0 to pcap_dispatch.
Previously they passed the packet pool size, but the packet_q_len
variable was now hardcoded at 0.

This patch sets packet_q_len to 64. If packet pool is empty, we fall
back to direct alloc. As the pcap_dispatch function is only called
when packet pool is not empty, we alloc at most 63 packets.

Update max-pending-packet comments to show it is now per-thread.

Updated suricata.yaml and comments in the code.

Add error checking for pthread_setspecific() and pthread_key_create().

Use posix_memalign instead of mm_malloc on non-Windows systems.

Implement thread specific data option when __thread is not available.

For PktPool add local pending freed packets list.

Better handle the autofp case where one thread allocates the majority
of the packets and other threads free those packets.

Add a list of locally pending packets. The first packet freed goes on the
pending list, then subsequent freed packets for the same Packet Pool are
added to this list until it hits a fixed number of packets, then the
entire list of packets is pushed onto the pool's return stack. If a freed
packet is not for the pending pool, it is freed immediately to its pool's
return stack, as before.

For the autofp case, since there is only one Packet Pool doing all the
allocation, every other thread will keep a list of pending packets for
that pool.

For the worker run mode, most packets are allocated and freed locally. For
the case where packets are being returned to a remote pool, a pending list
will be kept for one of those other threads, all others are returned as before.

Which remote pool for which to keep a pending list is changed each time the
pending list is returned. Since the return pending pool is cleared when it is
freed, then next packet to be freed chooses the new pending pool.

Replace ringbuffer in Packet Pool with a stack for better cache locality

Using a stack for free Packet storage causes recently freed Packets to be
reused quickly, while there is more likelihood of the data still being in
cache.

The new structure has a per-thread private stack for allocating Packets
which does not need any locking. Since Packets can be freed by any thread,
there is a second stack (return stack) for freeing packets by other threads.
The return stack is protected by a mutex. Packets are moved from the return
stack to the private stack when the private stack is empty.

Returning packets back to their "home" stack keeps the stacks from getting out
of balance.

The PacketPoolInit() function is now called by each thread that will be
allocating packets. Each thread allocates max_pending_packets, which is a
change from before, where that was the total number of packets across all
threads.

AC: shrink output table after initialization

AC: reduce realloc for new states

Don't realloc per state add, but grow by larger blocks per realloc.