detect: clean up stateful detect

stream: reduce scope of new ssn func

autotools: add src/tests to extra dist

stream: move inline tests

stream: list management cleanups

stream: debug improvements

stream inspection: add debug counters

stream: pack config struct

stream: enforce gap earlier in app reassembly

stream: don't call app reassembly if disable flag set

stream: app-layer micro optimizations

stream: raw reassembly explicit disable raw handling

stream: mpm inspect micro optimizations

stream: improve --disable-detection GAP handling

stream: remove unused StreamTcpGetStreamSize function

stream: optimize session pruning

doc: update for stream changes

yaml: sync with new stream engine

stream: validate code

detect: only do flow dependent cleanup if a flow is present

detect: make SigMatchSignatures void

None of the callers cared for it's retval, so get rid of it.

detect: turn single detect flag into bool

detect: remove unused detect flag

stream: improve needs reassembly code

stream: more aggressive StreamReassembleRawHasDataReady

app-layer: change logic of setting 'no reassembly'

Instead of killing all reassembly instantly do things slightly more
gracefully:
1. disable app-layer reassembly immediately
2. flag raw reassembly not to accept new data

This will allow the current data to be inspected still.

After detect as run the raw reassembly will be fully disabled and
thus all reassembly will be as well.

stream: new depth / disable raw logic

Depth reach sets NOREASSEMBLY after detect.

No new raw sets NORAW after detect.

stream: allow raw reassembly catch up

If raw reassembly falls behind, for example because no raw mpm is
active, then we need to sync up to the app progress if that is
available, or to the generic tcp tracking otherwise.

stream: detect stream GAP also during reassembly

debug-validation: add stream checks

stream: StreamTcpReassembleRawCheckLimit cleanup

stream: handle no stream scanning case

Now that detect moves the raw progress forward, it's important
to deal with the case where detect don't consider raw inspection.

If no 'stream' rules are active, disable raw. For this the disable
raw flag is now per stream.

stream: raw content inspection inline mode

Implement the inline mode for raw content inspection. Packets
are leading, and when a packet's payload has been added to the
stream, the packet is inspected in the context of the stream.

Reassembly will return a buffer with the packet data with older
data in front of it and after it, if available.

flow/stream: reduce/disable pseudo packet injections

At flow timeout, we no longer need to first run reassembly in
one dir, then inspection in the other. We can do both in single
packet now.

Disable pseudo packets when receiving stream end packets. Instead
call the app-layer parser in the packet direction for stream end
packets and flow end packets.

These changes in handling of those stream end packets make the
pseudo packets unnecessary.

stream: set 'trigger raw' per direction

detect / stream: new 'raw' stream inspection

Remove the 'StreamMsg' approach from the engine. In this approach the
stream engine would create a list of chunks for inspection by the
detection engine. There were several issues:

1. the messages had a fixed size, so blocks of data bigger than ~4k
   would be cut into multiple messages

2. it lead to lots of data copying and unnecessary memory use

3. the StreamMsgs used a central pool

The Stream engine switched over to the streaming buffer API, which
means that the reassembled data is always available. This made the
StreamMsg approach even clunkier.

The new approach exposes the streaming buffer data to the detection
engine. It has to pay attention to an important issue though: packet
loss. The data may have gaps. The streaming buffer API tracks the
blocks of continuous data.

To access the data for inspection a callback approach is used. The
'StreamReassembleRaw' function is called with a callback and data.
This way it runs the MPM and individual rule inspection code. At
the end of each detection run the stream engine is notified that it
can move forward it's 'progress'.

stream: constify StreamTcpReassembleRawCheckLimit

unittests: fail if TCP memory still in use

abort() so test can be analyzed.

stream-tcp: implement thread pool for segments

Config option:

stream:
  reassembly:
    segment-prealloc: 2048

stream: implement memory handling functions

stream: use static instead of dynamic streaming buffer structure

stream: test cleanups and fixes

stream: add insert failure counters

stream: add stream.reassembly.check-overlap-different-data option

stream: add tcp.overlap and tcp.overlap_diff_data counters

stream: improve no app and no raw case

stream: make raw_progress relative to STREAM_BASE_OFFSET

stream: make app_progress relative to STREAM_BASE_OFFSET

stream: reduce space used for progress tracking

Instead of the explicit base_seq_offset, use a macro instead. The
macro points to the stream buffer offset. The two were always
in sync.

stream: small cleanups

stream: remove unused zero copy setting

stream: safety check in overlap handling

tcp: streaming implementation

Make stream engine use the streaming buffer API for it's data storage.

This means that the data is stored in a single reassembled sliding
buffer. The subleties of the reassembly, e.g. overlap handling, are
taken care of at segment insertion.

The TcpSegments now have a StreamingBufferSegment that contains an
offset and a length. Using this the segment data can be retrieved
per segment.

Redo segment insertion. The insertion code is moved to it's own file
and is simplified a lot.

A major difference with the previous implementation is that the segment
list now contains overlapping segments if the traffic is that way.
Previously there could be more and smaller segments in the memory list
than what was seen on the wire.

Due to the matching of in memory segments and on the wire segments,
the overlap with different data detection (potential mots attacks)
is much more accurate.

Raw and App reassembly progress is no longer tracked per segment using
flags, but there is now a progress tracker in the TcpStream for each.

When pruning we make sure we don't slide beyond in-use segments. When
both app-layer and raw inspection are beyond the start of the segment
list, the segments might not be freed even though the data in the
streaming buffer is already gone. This is caused by the 'in-use' status
that the segments can implicitly have. This patch accounts for that
when calculating the 'left_edge' of the streaming window.

Raw reassembly still sets up 'StreamMsg' objects for content
inspection. They are set up based on either the full StreamingBuffer,
or based on the StreamingBufferBlocks if there are gaps in the data.

Reworked 'stream needs work' logic. When a flow times out the flow
engine checks whether a TCP flow still needs work. The
StreamNeedsReassembly function is used to test if a stream still has
unreassembled segments or uninspected stream chunks.

This patch updates the function to consider the app and/or raw
progress. It also cleans the function up and adds more meaningful
debug messages. Finally it makes it non-inline.

Unittests have been overhauled, and partly moved into their own files.

Remove lots of dead code.

streaming: remove BUG_ON and other improvements

Can be triggered by memory limits.

streaming: add blocklist

Add list of 'blocks'. This list contains offsets and lengths to
continuous data blocks. This is useful for TCP tracking where we
can have data gaps.

The blocks don't contain any data themselves, instead they contain
lenght and offsets. This way no extra copying is needed.

On inserting new data, existing blocks are expanded instead of
having multiple neighbouring blocks.

stream-tcp: StreamTcpUTAddPayload unittest helper

profile: account flow-worker tcp-prune step

doc: http keywords update

detect: implement http_content_len sticky buffer

This implements inspection of the Content-Length buffer as a content
sticky buffer.

detect: implement http_content_type sticky buffer

detect: implement http_accept_enc sticky buffer

Inspects Accept-Encoding header.

detect: implement http_accept_lang sticky buffer

Inspects Accept-Language header

detect: implement http_connection sticky buffer

detect: implement http referer sticky buffer

detect: http_accept sticky buffer + common code

Implement common code to easily add more per HTTP header detection
keywords.

Implement http_accept sticky buffer. It operates on the HTTP Accept
header.

tls: logging for session resumption

We assume session resumption has occurred if the Client Hello message
included a session id, we have not seen the server certificate, but
we have seen a Change Cipher Spec message from the server.

Previously, these transactions were not logged at all because the
server cert was never seen.

Ticket: https://redmine.openinfosecfoundation.org/issues/1969

device: fix warning about NULL device

Fix '[ERRCODE: SC_ERR_INVALID_VALUE(130)] - Name of device should not be null'
warning on start-up with pfring.

Ticket: https://redmine.openinfosecfoundation.org/issues/2097

redis: use SCCalloc to reduce risk of unitialized vars

eve: async mode for redis output

eve: detects libevent for async redis at configure
eve: moves redis output code to new file - util-log-redis.{c,h}
eve: redis ECHO and QUIT commands for async mode
eve: redis output defaults if conf is missing

doc: async mode for redis eve output

async: true ## if redis replies are read asynchronously

qa: add --no-random commandline option

qa: add rand/rand_r to banned functions

random: convert stream and htp to new call

random: improve random logic

Improve random logic for hash tables.

Implement Windows random API if it is available.

mingw: don't use uint type as mingw doesn't have it

common: improve byte order and wordsize detection

core dumps: check for sys/resource.h

cleanup: get rid of %llu format specifiers

Use more explicit types instead.

doc: Napatech docs improvement

Fix errors and simplify filters.

template script: typo in app-layer setup script

Check for ed was failing, as it was actually looking for edx.

pcre: on ppc64 disable only for specific versions

Disable jit only for libpcre 8.39 and 8.40 as those were the buggy
versions.

Thanks to Zoltán Herczeg.

doc: expand on bpf

detect: don't consider an empty rule file an error

logging: only do non-blocking writes if live

If running against a pcap there is no reason to drop events,
a blocking socket is fine here. So only do non-blocking writes
when running off a live device.

eve: log number of events dropped at exit

logging: don't block on socket writes

Writing to a unix socket can cause Suricata to block in the
packet path. This could happen if the read-endpoint of the
unix socket stays connected, but stops reading, or simply
can't read fast enough as part of its event processing.

To choose packets over events, do non-blocking socket
writes and drop the event if the write would block and
update a dropped counter.

doc: add documentation for date modifiers in eve-log

doc: add documentation for eve-log file rotation

logging: create log directories when needed

Recursively create new log directories when needed. This makes it
possible to use date modifiers in the file path to create
directories based on date, e.g.:

  /var/log/suricata/2017/02/14/

output-json: rotate log file based on time

Rotate log file based on time. Support both rotating based on a timer (XXs,
XXm, XXd, XXw) and rotating based on a absolute time, like each minute,
hour or day.

logging: support date modifiers in log filenames

Allow log filenames to contain date modifiers, e.g.:

  - eve-log:
    filename: eve-%Y-%m-%d-%H:%M:%S.json

pcre: disable jit on powerpc64

It appears that both using gcc and clang something gets misoptimised
around pcre's jit. So disable jit for now.

defrag: (windows) detect more overlaps

defrag: (linux) fix an error in overlapping fragments

If a subsequent fragment has a lower offset than a previous
one and overlaps, trim off the beginning of the previous
fragment.

Based on an issue reported privately.

defrag: use new unit test macros

Also reformat unit test functions to Suricata style.

travis: use new container build infrastructure

Migrate to the new Travis container build system. This build system does
not allow use of sudo, so required packages must be done declaratively
which required reworking how we install packages that are conditional
based on the build being done.

Mac builds are still done with sudo=true.

unix-socket: return failure on failure

UnixManagerThreadInit needs to return a failure code if the socket
fails to initialize to avoid entering the UnixManager loop which
will continuously fail on the call to bind, as no listening
socket was setup.

This can occur when the socket fails to initialize due to a
permissions error and fatal init errors is not on.

log: tls custom format log

log: common custom format output

geoip: fix compiler warning

detect-geoip.c:78:40: error: incompatible pointer types assigning to 'int (*)(ThreadVars *, DetectEngineThreadCtx *, Packet *, const Signature *, const SigMatchCtx *)' from 'int (ThreadVars *, DetectEngineThreadCtx *, Packet *, Signature *, const SigMatchCtx *)' [-Werror,-Wincompatible-pointer-types]
    sigmatch_table[DETECT_GEOIP].Match = DetectGeoipMatch;
                                       ^ ~~~~~~~~~~~~~~~~
1 error generated.

Bug #2045