netmap support

file: register filedata log before file log

This way the file log can log the 'stored' info that the filedata
log sets.

file: improve file pruning

Check if file has been logged/stored before considering it 'done'.

runmodes: add funcs to check if file loggers enabled

Add functions to check if file/filedata loggers are enabled.

file: optimize file pruning

FilePrune would clear the files, but not free them and remove them
from the list. This lead to ever growing lists in some cases.
Especially in HTTP sessions with many transactions, this could slow
us down.

flow: lockless flow manager checks

Until this point, the flow manager would check for timed out flows
by walking the flow hash, locking first the hash row and then each
individual flow to get it's state and timestamp. To not be too
intrusive trylocks were used so that a busy flow wouldn't cause the
flow manager to wait for a long time while holding the hash row lock.

Building on the changes in handling of the flow state and lastts
fields, this patch changes the flow managers behavior.

It can now get a flows state atomically and the lastts can be safely
read while holding just the flow hash row lock. This allows the flow
manager to do the basic time out check much more cheaply:

1. it doesn't have to wait for getting a lock
2. it doesn't interupt the packet path

As a consequence the trylock is now also gone. A flow that returns
'true' on timeout is pretty much certainly not going to be busy so
we can safely lock it unconditionally. This also means the flow
manager now walks the entire row unconditionally and is guaranteed
to inspect each flow in the row.

To make sure the functions called before the flow lock don't
accidentally change the flow (which would require a lock) the args
to these flows are changed to const pointers.

flow: modify lastts update logic

In the lastts timeval struct field in the flow the timestamp of the
last packet to update is recorded. This allows for tracking the timeout
of the flow. So far, this value was updated under the flow lock and also
read under the flow lock.

This patch moves the updating of this field to the FlowGetFlowFromHash
function, where it updated at the point where both the Flow and the
Flow Hash Row lock are held. This guarantees that the field is only
updated when both locks are held.

This makes reading the field safe when either lock is held, which is the
purpose of this patch.

The flow manager, while holding the flow hash row lock, can now safely
read the lastts value. This allows it to do the flow timeout check
without actually locking the flow.

flow: change flow state logic

A flow has 3 states: NEW, ESTABLISHED and CLOSED.

For all protocols except TCP, a flow is in state NEW as long as just one
side of the conversation has been seen. When both sides have been
observed the state is moved to ESTABLISHED.

TCP has a different logic, controlled by the stream engine. Here the TCP
state is leading.

Until now, when parts of the engine needed to know the flow state, it
would invoke a per protocol callback 'GetProtoState'. For TCP this would
return the state based on the TcpSession.

This patch changes this logic. It introduces an atomic variable in the
flow 'flow_state'. It defaults to NEW and is set to ESTABLISHED for non-
TCP protocols when we've seen both sides of the conversation.

For TCP, the state is updated from the TCP engine directly.

The goal is to allow for access to the state without holding the Flow's
main mutex lock. This will later allow the Flow Manager(s) to evaluate
the Flow w/o interupting it.

tcp: add stream.reassembly.zero-copy-size option

The option sets in bytes the value at which segment data is passed to
the app layer API directly. Data sizes equal to and higher than the
value set are passed on directly.

Default is 128.

tcp: add debug stats about reassembly fast paths

Only shown if --enable-debug is passed to configure.

tcp: zero copy fast path in app-layer reassembly

Create 2 'fast paths' for app layer reassembly. Both are about reducing
copying. In the cases described below, we pass the segment's data
directly to the app layer API, instead of first copying it into a buffer
than we then pass. This safes a copy.

The first is for the case when we have just one single segment that was
just ack'd. As we know that we won't use any other segment this round,
we can just use the segment data.

The second case is more aggressive. When the segment meets a certain
size limit (currently hardcoded at 128 bytes), we pass it to the
app-layer API directly. Thus invoking the app-layer somewhat more often
to safe some copies.

stream: move raw stream gap handling into util func

stream: move raw reassembly into util func

stream: remove StreamTcpReassembleInlineAppLayer

Function is now unused.

stream: unify inline and non-inline applayer assembly

Unifiy inline and non-inline app layer stream reassembly to aid
maintainability of the code.

stream: remove STREAM_SET_FLAGS

Use the unified StreamGetAppLayerFlags instead.

stream: update inline tests

Make sure inline tests set the stream_inline flag.

stream: replace STREAM_SET_INLINE_FLAGS macro

Replace it by a generic function StreamGetAppLayerFlags, that can
be used both by inline and non-inline.

stream: track data sent to app-layer

stream: move reassembly loop into util funcs

Move IDS per segment reassembly and gap handling into utility functions.

Update changelog for 2.1beta3

detect: fix small memory leaks

Fix small memory leaks in option parsing. Move away from
pcre_get_substring in favor of pcre_copy_substring.

Related to #1046.

Clean up Conf API memory on shutdown.

Fix live reload detect counter setup

When profiling was compiled in the detect counters were not setup
properly after a reload.

conf api: use const pointers where possible

Use const pointers where possible in the Conf API.

Cosmetic fixes to main()

Suppress debug statements

detect: properly size det_ctx::non_mpm_id_array

Track which sgh has the higest non-mpm sig count and use that value
to size the det_ctx::non_mpm_id_array array.

Fix live reload detect thread ctx setup

Code failed to setup non_mpm_id_array in case of a live reload.

AC: fix memory leak

geoip: adapt to 'const' pointer passing

detect: expand mask checking

Change mask to u16, and add checks for various protocol states
that need to be present for a rule to be considered.

detect: introduce DetectPrefilterBuildNonMpmList

Move building of non-mpm list into a separate function, that is inlined
for performance reasons.

detect: add profiling for non-mpm list build & filter

detect: optimize non-mpm mask checking

Store id and mask in a single array of type SignatureNonMpmStore so
that both are loaded into the same cache line.

detect: add mask check prefilter for non mpm list

Add mask array for non_mpm sigs, so that we can exclude many sigs before
we merge sort.

Shows 50% less non mpm sigs inspected on average.

Conditionalize SigMatch performance counters.

Only include the counters when PROFILING.

Detect perf counters

detect: Disable unused SignatureHeader code

Remove sgh->mask_array

Not needed by new MPM opt.

Indentation clean up

Further optimize merging mpm and non-mpm rule ID lists.

When reaching the end of either list, merging is no longer required,
simply walk down the other list.

If the non-MPM list can't have duplicates, it would be worth removing
the duplicate check for the non-MPM list when it is the only non-empty list
remaining.

Custom Quick Sort for Signature IDs

Use an in place Quick Sort instead of qsort(), which does merge sort and
calls memcpy().

Improves performance on my tests.

Use SigIntId as the type for storing signature IDs (Internal)

Previously using uint32_t, but SigIntId is currently uint16_t, so arrays
will take less memory.

Increase max pattern ID allowed in MPM AC-tile to 28-bits

Clean up sm_array memory at SigFree

Create optimized sig_arrays from sig_lists

Create a copy of the SigMatch data in the sig_lists linked-lists and store
it in an array for faster access and not next and previous pointers. The
array is then used when calling the Match() functions.

Gives a 7.7% speed up on one test.

Change Match() function to take const SigMatchCtx*

The Match functions don't need a pointer to the SigMatch object, just the
context pointer contained inside, so pass the Context to the Match function
rather than the SigMatch object. This allows for further optimization.

Change SigMatch->ctx to have type SigMatchCtx* rather than void* for better
type checking. This requires adding type casts when using or assigning it.

The SigMatch contex should not be changed by the Match() funciton, so pass it
as a const SigMatchCtx*.

Create Specialized SCMemcmpNZ() when the length can't be zero.

Replace memcpy() in MpmAddSids with copy loop

For the short size of most sids lists, a straight copy loop is faster.

Fix compiler warnings in ac-tile.

Signed vs unsigned comparisons.

Prefetch the next signature pointer

Read one signature pointer ahead to prefetch the value.
Use a variable, sflags, for s->flags, since it is used many times and the
compiles doesn't know that the signatures structure doesn't change, so it
will reload s->flags.

Move type first in SigMatch array since it is used more often.

In AC-Tile, convert from using pids for indexing to pattern index

Use an MPM specific pattern index, which is simply an index starting
at zero and incremented for each pattern added to the MPM, rather than
the externally provided Pattern ID (pid), since that can be much
larger than the number of patterns. The Pattern ID is shared across at
MPMs. For example, an MPM with one pattern with pid=8000 would result
in a max_pid of 8000, so the pid_pat_list would have 8000 entries.

The pid_pat_list[] is replaced by a array of pattern indexes. The PID is
moved to the SCACTilePatternList as a single value. The PatternList is
also indexed by the Pattern Index.

max_pat_id is no longer needed and mpm_ctx->pattern_cnt is used instead.

The local bitarray is then also indexed by pattern index instead of PID, making
it much smaller. The local bit array sets a bit for each pattern found
for this MPM. It is only kept during one MPM search (stack allocated).

One note, the local bit array is checked first and if the pattern has already
been found, it will stop checking, but count a match. This could result in
over counting matches of case-sensitve matches, since following case-insensitive
matches will also be counted. For example, finding "Foo" in "foo Foo foo" would
report finding "Foo" 2 times, mis-counting the third word as "Foo".

Fix missing use of MpmAddPid()

Found by Victor using ASAN. One place was not checking to resize the
pid array before adding a new PID.

fix check in PmqMerge

Fix bug in MPM rule array handling

In PmqMerge() use MpmAddSids() instead of blindly copying the src
rule list onto the end of the dst rule list, since there might not
be enough room in the dst list. MpmAddSids() will resize the dst array
if needed.

Also add code to MpmAddSids() MpmAddPid() to better handle the case
that realloc fails to get more space. It first tries 2x the needed
space, but if that fails, it tries for just 1x. If that fails resize
returns 0. For MpmAddPid(), if resize fails, the new pid is lost. For
MpmAddSids(), as many SIDs as will fit are added, but some will be
lost.

Dynamically resize pattern id array as needed

Rather than creating the array of size maxpatid, dynamically resize as needed.
This also handles the case where duplicate pid are added to the array.

Also fix error in bitarray allocation (local version) to always use bitarray_size.

Dynamically resize pmq->rule_id_array

Rather than statically allocate 64K entries in every rule_id_array,
increase the size only when needed. Created a new function MpmAddSids()
to check the size before adding the new sids. If the array is not large
enough, it calls MpmAddSidsResize() that calls realloc and does error
checking. If the realloc fails, it prints an error and drops the new sids
on the floor, which seems better than exiting Suricata.

The size is increased to (current_size + new_count) * 2. This handles the
case where new_count > current_size, which would not be handled by simply
using current_size * 2. It should also be faster than simply reallocing to
current_size + new_count, which would then require another realloc for each
new addition.

Fix clang warning

Clang doesn't seem to like defining a function within a function.

Optimize DetectPrefilterMergeSort

Fixup rebase changes to remove debug code

Implement MPM opt for ac-bs and ac-gfbs

Copies sids changes from ac.

Implement MPM opt for b2g, b3g, wumanber

Found problems in b2gm and b2gc, so those are removed.

Fix AC-tile for new pattern ID array.

AC: use local bit array

Use a local pattern bit array to making sure we don't match more than
once, in addition to the pmq bitarray that is still used for results
validation higher up in the rule matching process.

Why: pmq->pattern_id_bitarray is currently sometimes used in a
'stateful' way, meaning that for a single packet we run multiple
MPM's on the same pmq w/o resetting it.

The new bitarray is used to determine wherther we need to append the
patterns associated 'sids' list to the pmq rule_id_array.

It has been observed that MPM1 matches for PAT1, and MPM2 matches for
PAT1 as well. However, in MPM1 PAT1 doesn't have the same sids list.
In this case MPM2 would not add it's sids to the list, leading to missed
detection.

detect: move checks from prefilter to rule detect

Move the prefilter checks to the main detect loop.

Replace build match array with new filter logic

Use MPM and non-MPM lists to build our match array. Both lists are
sorted, and are merged and sorted into the match array.

This disables the old match array building code and thus also bypasses
the mask checking.

detect: Add negated MPM to non-MPM array

Treat negated MPM sigs as if non-MPM, so we consider them always.

As MPM results and non-MPM rules lists are now merged and considered
for further inspection, rules that need to be considerd when a pattern
is absent are caught in the middle.

As a HACK/workaround this patch adds them to the non-MPM list. This
causes them to be inspected each time.

Detect: create per sgh non-MPM rule array

Array of rule id's that are not using MPM prefiltering. These will be
merged with the MPM results array. Together these should lead to a
list of all the rules that can possibly match.

MPM: build sid list from MPM matches

Pmq add rule list: Array of uint32_t's to store (internal) sids from the MPM.

AC: store sids in the pattern list, append to Pmq::rule_id_array on match.

Detect: sort rule_id_array after it was set up by the MPM. Rule id's
(Signature::num) are ordered, and the rule's with the lowest id are to
be inspected first. As the MPM doesn't fill the array in order, but instead
'randomly' we need this sort step to assure proper inspection order.

Create a wrapper around DetectFlowvarProcessList() to check for empty list

Creates an inline wrapper to check for flowvarlist == NULL before calling
DetectFlowvarProcessList() to remove the overhead of checking since the
list is usually empty.

Remove the b2gm and b2gc MPMs

These MPMs have code that looks like it won't work and updating them to
for the new MPM optimization wasn't working.

Global define of MIN

Some OS' provide it automatically, so make sure we define it
conditionally in one place.

Fix a fix: defrag OOM condition

** CID 1257764:  Dereference after null check  (FORWARD_NULL)
/src/defrag.c: 291 in Defrag4Reassemble()

** CID 1257763:  Dereference after null check  (FORWARD_NULL)
/src/defrag.c: 409 in Defrag6Reassemble()

In the error case 'rp' can be both NULL or non-NULL.

detect: add test for memcmp issue

Add test for memcmp issue.

memcmp: compare the first byte as well

MemcmpLowercase would not compare the first byte of both input buffers
leading to two non-identical buffers to be considered the same.

Affects SSE_4_1 and SSE_4_2 implementations of SCMemcmpLowercase, as well
as the non-SIMD implementation. SSE_3 and Tile version are not affected.

Fix OS X 10.10 unittest failure

Work around OS X 10.10 Yosemite returning EDEADLK on a rwlock wrlocked
then tested by wrtrylock. All other OS' (and versions of OS X that I
tested) seem to return EBUSY instead.

Fix Tilera compilation

Use proper initializer for a static mutex declaration.

Credits: Ken Steele

Fix compilation on OS X Yosemite

Due to our unconditional declaration of the strlcat and strlcpy
functions, compilation failed on OS X Yosemite.

Bug #1192

Update reference.config

Updated reference.config to match ET Open reference.config found here:
https://rules.emergingthreats.net/open/suricata/reference.config

Due to startup error shown here:
root@xxxxxxx01:/etc/suricata/rules# /usr/bin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid --af-packet
23/12/2014 -- 22:07:56 - <Error> - [ERRCODE: SC_ERR_REFERENCE_UNKNOWN(150)] - unknown reference key "osvdb". Supported keys are defined in reference.config file.  Please have a look at the conf param "reference-config-file"
<...>
Killed

Respect DESTDIR in install-conf and install-rules.

unix socket: support profiling

smtp: fix tx handling

Fix issue where SMTPStateGetTxCnt would return the actual active tx'.

The 'GetCnt' API call is not named correctly. It should be 'GetMaxId',
as this is actually the expected behavior.

thread local storage: add to build-info

packet pool: make pending pool use more robust

Don't leave pointers dangling.

packet pool: memory fixes for non-TLS

If the posix TLS implementation is used, the packet pool is memset to
0 before use.

Also use proper 'free' function.

configure: add switch to disable __thread use

Add --disable-threading-tls switch to force the posix thread local
storage code paths even if __thread is available.

Goal is to make it easier to QA the posix code path.

packet pool: fix wrong free call

app-layer: fix 'detection-only' keyword

If we follow the description in the yaml file, we should disable
parsing if 'detection-only' keyword is used.

output-json: fix duplicate logging

This patches is fixing a issue in the OutputJSONBuffer function. It
was writing to file the content of the buffer starting from the start
to the final offset. But as the writing is done for each JSON string
we are duplicating the previous events if we are reusing the same
buffer.

Duplication was for example triggered when we have multiple alerts
attached to a packet. In the case of two alerts, the first one was
logged twice more as the second one.

stream: improve inline mode GAP handling

Don't conclude a GAP is 'final' until the missing data is ack'd.

Further, cleanup and unify more with the non-inline code.

stream: move utility functions

This way they can be used by the *Inline* functions as well.

host: register unittests

Host unittests were not registered so they wouldn't run.

packet-pool: free pending packets

stats: stats threads don't need packet pools

flow manager: destroy packet pool on close

flow-timeout: use packet pool

Use packet pool for pseudo packets on flow timeout. Wait for a packet
if necessary.

For shutdown, alloc a new pool as the 'main()' thread calls this.

threading: lock TmThreadKillThreadsFamily

flow timeout: cleanups

Rename FlowForceReassemblyForFlowV2 to just FlowForceReassemblyForFlow
as there is no V1.