util-ioctcl: increase header size

Headers can contain VLAN or Qing so we need to increase the value
returned by GetIfaceMaxHWHeaderLength.

suricata: fix double packet processing threads

With the additional ParseInterfacesList the packet processing threads
were doubled since the Interface was included twice unless the device
was passed via the commandline with af-packet=IF.
The additonal ParseInterfacesList isn't necessary so remove it again

ac-ks: don't allow use on big-endian

flow-worker: small cleanups

detect: make pattern matcher messages less verbose

yaml: replace ac-tile by ac-ks

yaml: remove conf_filename global

conf_filename was a global pointer to the filename of the yaml.

Move into SCInstance. This reduces it's scope and cleans up the code.

profiling: fix compilation if libjansson is missing

pfring: cleanup

pfring: improve profiling

Reset packet profiling after pfring_recv. The packet was taken from
the packet pool before this call. The packet will already have it's
start ticks initialized. To avoid including ticks while pfring_recv
waits for traffic, reset the ticks right after it.

profiling: allow packet profiling to be reset

coverity: fix CID 1362014

Error handling was not correct regarding ring buffer memory
handling.

af-packet: use better defaults if config is missing

yaml: make eve log in yaml depend on libjansson

yaml: improve capture comments

yaml: move classification etc below the rules

yaml: new defaults for outputs

Enable eve.flow, disable plain http.log.

yaml: file logging at info level

yaml: improved defaults and misc cleanups

yaml: add performance tuning section

yaml: more reshuffling

yaml: create advancted sections

Sections for advancted detection settings and traffic tracking and
reconstruction.

yaml: add hw accel section, move cuda there

yaml: add netfilter section

yaml: move outputs to the logging step

yaml: introduce 'advanced settings'

yaml: move app layer up

yaml: move afpacket, pcap, pcap-file up

yaml: move logging up

yaml: move rules up in the file

Also disable decoder and stream events by default, as they are too noisy
in a untuned environment.

yaml: move vars to the top

logging: clean up at shutdown

flow worker: move UDP app-layer into main function

This way it's more clean what happens and we can profile it.

flow worker: profiling

Previously the detect and stream code lived in their own thread
modules. This meant profiling showed their cost as part of the
thread module profiling logic. Now that only the flow worker is
a thread module this no longer works.

This patch introduces profiling for the 3 current flow worker
steps: flow, stream, detect.

debug: fix compiler warnings

thread modules: remove unused id's

detect: no longer a thread module

Like stream, detect is now invoked directly by the FlowWorker.

stream-tcp: more cleanups

stream-tcp: no longer register as a thread module

Now that the FlowWorker handles the TCP Stream directly, having
the TCP engine as a thread module is no longer needed.

This patch removes the registration.

drmemory: broader suppressions for hyperscan

smtp: improve thread data use

The SMTP app layer used a thread local data structure for the mpm in
reply parsing, but it only used a pmq. The MpmThreadCtx was actually
global. Until now this wasn't really noticed because non of the mpm's
used the thread ctx.

Hyperscan does use it however.

This patch creates a new structure SMTPThreadCtx, which contains both
the pmq and the mpm thread ctx. It's passed directly to the reply
parsing function instead of storing a pointer to it in the SMTPState.

Additionally fix a small memory leak warning wrt the smtp global mpm
state.

app-layer-smtp: free mpm contexts on shutdown

Adds a cleanup function for the SMTP parser that destroys the MPM
context and MPM thread context it uses.

Also marks smtp_mpm_thread_ctx static.

detect-engine: log MPM/SPM matchers being used

mpm: add "auto" default for mpm-algo

Setting mpm-algo to "auto" will use "hs" if Suricata was built against
Hyperscan, and "ac" otherwise (or "ac-tile" on Tilera platforms).

app-layer-detect-proto: use mpm-algo

Use the matcher configured by the user rather than hard-coding MPM_AC.

app-layer-detect-proto: pass mpm_ctx to DestroyCtx

The MPM DestroyCtx function accepts the MpmCtx, not the ctx pointer
inside it.

detect-engine: adjust unit tests for hs mpm

The Hyperscan MPM does match deduplication internally (using
HS_FLAG_SINGLEMATCH) and only returns the number of unique matches,
unlike AC.

app-layer-smtp: init mpm thread ctx after prepare

This allows the Hyperscan MPM to correctly allocate scratch.

mpm-hs: make errors from hs_scan() fatal

Hyperscan will only return an error at scan time if the database or
scratch region are corrupted, which should provoke a fatal error.

mpm-hs,spm-hs: don't call hs_scan() for zero bytes

netmap: close sw ring before hw rings
Fix issue #1714

tls-json-log: register module as tls-json-log, not dns-json-log

Fixes issue:
https://redmine.openinfosecfoundation.org/issues/1792
where dns-json-log would not log any data.

prscript: fix error handling

Last result was used as global result.

isdataat: remove unused code

src/: fix typo: receieved vs received

Reported by Debian's lintian tool.

Signed-off-by: Arturo Borrero Gonzalez <arturo.borrero.glez@gmail.com>

flow worker: set up decoder thread vars

ac: allow use of 31bits of pid space instead of 16

dns: add support for sshfp records

Update parser to process the records.

Update json output to log it.

coverity: CID 1362011: Control flow issues (DEADCODE)

coverity: CID 1362012: Incorrect expression (EVALUATION_ORDER)

coverity CID 1362013: Control flow issues (NESTING_INDENT_MISMATCH)

af-packet: CentOS6 build fixes

af-packet: use time() instead of GetTime()

As we only use the second we don't need GetTime() which is slower
and get us milliseconds.

af-packet: print errno on mmap error

af-packet: fix some typos in yaml

af-packet: ask for hardware timestamp

af-packet: make mmap options parsing conditional

Only parse them if mmap is activated.

af-packet: reset stats at start of capture

We can loose packets during setup because we are reading nothing.
So it is logical to discard the counter at start of capture to
start from a clean state. This means we don't need to account the
drop at start. But the stats call that will reset the drop counts
will also return and reset the packets count. So we need to know
how many packets we really have. This is in fact the number of
packets coming from the stats call minus the number of discarded
packets and the drop count. All the other packets will have to be
read.

af-packet: use mmap capture by default

Update the code to use mmap capture by default even in unset in
configuration file. mmap capture is now be turned off by using
explicitely 'use-mmap: no' in configuration.

af-packet: detect availability of tpacket_v3

If TPACKET_V3 is not defined then it is not available and we should
not build anything related to tpacket_v3. This will allow us to
activate it dy default and fallback to v2 if not available.

af-packet: add option to use memory locked mmap

af-packet: configurable tpacket_v3 block timeout

Block timeout defines the maximum filling duration of a block.

af-packet: configurable tpacket_v3 block size

It is used to set the block size in tpacket_v3. It will allow user
to tune the capture depending on his bandwidth.

Default block size value has been updated to a bigger value to
allow more efficient wlak on block.

af-packet: put ring setup in a separate function

af-packet: pack AFPPeer structure

af-packet: AFPWalkBlock error handling

Error handling was not done. The implementation is making the
choice to consider we must detroy the socket in case of parsing
error. The same was done for tpacket_v2.

af-packet: continuing cleaning and hole hunting

Suppress useless fields in AFPThreadVars. This patch also get rid
of bytes counter as it was only used to display a message at exit.
Information on livedev and on packet counters are enough.

af-packet: cleaning and hole hunting

Reorder fields in AFPThreadVars and suppress some that were not
used elsewhere than in the initialization.

af-packet: tpacket_v3 implementation

This patch adds a basic implementation of AF_PACKET tpacket v3. It
is basic in the way it is only working for 'workers' runnning mode.
If not in 'workers' mode there is a fallback to tpacket_v2. Feature
is activated via tpacket-v3 option in the af-packet section of
Suricata YAML.

af-packet: remove useless code

No need for cooked header in the case of mmap capture.

af-packet: micro optimization

af-packet: avoid test for each packet

spm: handle null ptrs in destroy funcs gracefully

This will handle minimal DetectEngineCtx structures (used in delayed
detect mode) safely, since they don't get SPM global contexts allocated.

Also added BUG_ON checks for valid spm_table entries.

file: switch to streaming buffer API

Make the file storage use the streaming buffer API.

As the individual file chunks were not needed by themselves, this
approach uses a chunkless implementation.

http: improve body inspection

Enforce inspect window also in IDS mode. Try always to get at least
'inspect win' worth of data. In case there is more new data, take
some of the old data as well to make sure there is always some overlap.

This unifies IDS and IPS modes, the only difference left is the start
of inspection. IDS waits until min_size is available, IPS starts right
away.

http: make htpstate cfg ptr const

http: move body settings into per dir struct

http: add per direction config for body parsing

The HTPCfgDir structure is meant to contain config for per direction
body parsing parameters.

This patch stores the streaming API config.

http body handling: use streaming buffer API

Convert HTTP body handling to use the Streaming Buffer API. This means
the HtpBodyChunks no longer maintain their own data segments, but
instead add their data to the StreamingBuffer instance in the HtpBody
structure.

In case the HtpBodyChunk needs to access it's data it can do so still
through the Streaming Buffer API.

Updates & simplifies the various users of the reassembled bodies:
multipart parsing and the detection engine.

streaming: buffer API

Add a new API to store data from streaming sources, like HTTP body
processing or TCP data.

Currently most of the code uses a pattern of list of data chunks
(e.g. TcpSegment) that is reassembled into a large buffer on-demand.

The Streaming Buffer API changes the logic to store the data in
reassembled form from the start, with the segments/chunks pointing
to the reassembled data.

The main buffer storing the data slides forward, automatically or
manually. The *NoTrack calls allows for a segmentless mode of
operation.

This approach has two main advantages:

1. accessing the reassembled data is virtually cost-free
2. reduction of allocations and memory management

autofp: update queue handlers

Now that the flow lookup is done in the worker threads the flow
queue handlers running after the capture thread(s) no longer have
access to the flow. This limits the options of how flow balancing
can be done.

This patch removes all code that is now useless. The only 2 methods
that still make sense are 'hash' and 'ippair'.

flow: remove dead code

flowworker: initial support

Initial version of the 'FlowWorker' thread module. This module
combines Flow handling, TCP handling, App layer handling and
Detection in a single module. It does all flow related processing
under a single flow lock.

detect: simplify flow locking

To simplify locking, move all locking out of the individual detect
code. Instead at the start of detection lock the flow, and at the
end of detection unlock it.

The lua code can be called without a lock still (from the output
code paths), so still pass around a lock hint to take care of this.

time: improve offline time handling

When we run on live traffic, time handling is simple. Packets have a
timestamp set by the capture method. Management threads can simply
use 'gettimeofday' to know the current time. There should never be
any serious gap between the two or major differnces between the
threads.

In offline mode, things are dramatically different. Here we try to keep
the time from the pcap, which means that if the packets are recorded in
2011 the log output should also reflect this. Multiple issues:

 1. merged pcaps might have huge time jumps or time going backward
 2. slowly recorded pcaps may be processed much faster than their
    'realtime'
 3. management threads need a concept of what the 'current' time is for
    enforcing timeouts
 4. due to (1) individual threads may have very different views on what
    the current time is. E.g. T1 processed packet 1 with TS X, while T2
    at the very same time processes packet 2 with TS X+100000s.

The changes in flow handling make the problems worse. The capture thread
no longer handles the flow lookup, while it did set the global 'time'.
This meant that a thread may be working on Packet 1 with TS 1, while the
capture thread already saw packet 2 with TS 10000. Management threads
would take TS 10000 as the 'current time', considering a flow created by
the first thread as timed out immediately.

This was less of a problem before the flow changes as the capture thread
would also create a flow reference for a packet, meaning the flow
couldn't time out as easily. Packets in the queues between capture
thread and workers would all hold such references.

The patch updates the time handling to be as follows.

In offline mode we keep the timestamp per thread. If a management thread
needs current time, it will get the minimum of the threads' values. This
is to avoid the problem that T2s time value might already trigger a flow
timeout as the flow lastts + 100000s is almost certainly meaning the
flow would be considered timed out.

flow: move flow handling into worker threads

Instead of handling the packet update during flow lookup, handle
it in the stream/detect threads. This lowers the load of the
capture thread(s) in autofp mode.

The decoders now set a flag in the packet if the packet needs a
flow lookup. Then the workers will take care of this. The decoders
also already calculate the raw flow hash value. This is so that
this value can be used in flow balancing in autofp.

Because the flow lookup/creation is now done in the worker threads,
the flow balancing can no longer use the flow. It's not yet
available. Autofp load balancing uses raw hash values instead.

In the same line, move UDP AppLayer out of the DecodeUDP module,
and also into the stream/detect threads.

Handle TCP session reuse inside the flow engine itself. If a looked up
flow matches the packet, but is a TCP stream starter, check if the
ssn needs to be reused. If that is the case handle it within the
lookup function. Simplies the locking and removes potential race
conditions.

flow: get flow reference during lookup

Update Flow lookup functions to get a flow reference during lookup.

This reference is set under the FlowBucket lock.

This paves the way to not getting a flow lock during lookups.

detect: split detect entry into flow/noflow

This is a preparation for flow locking updates.

detect: add (mpm) keyword for tls_sni

Match on server name indication (SNI) extension in TLS using tls_sni
keyword, e.g:

alert tls any any -> any any (msg:"SNI test"; tls_sni;
        content:"example.com"; sid:12345;)

typo: SURCATA -> SURICATA