bypass: add explicit flag in stream engine

TCP reassembly is now deactivated more frequently and triggering a
bypass on it is resulting in missing some alerts due forgetting
about packet based signature.

So this patch is introducing a dedicated flag that can be set in
the app layer and transmitted in the streaming to trigger bypass.

It is currently used by the SSL app layer to trigger bypass when
the stream becomes encrypted.

rust/dns: support gaps in TCP DNS

travis: add rust 1.7.0 build

One build with Rust 1.7.0, our oldest that we'll support as its
whats bundled with Ubuntu 16.04. Create another build that will use
the latest stable.

rust/dns: fix unit tests on Rust 1.7.0

rust/dns: support txt records

rust/dns: copy over dns unit tests

Only the tests that make sense were copied over, those testing
correlation of responses to requests were not.

Also, remove compiler warning when not built with
unit tests.

rust: don't fail distcheck if cargo-vendor not found

Allow distcheck to pass if cargo vendor is not found by not
failing out. It is not required to successfully build a dist
tarball, the Rust sources will just not be vendored in.

Also don't fail out make dist if Python is not installed. A build
will still be successful is Python is available on the end
build system.

output-json-alert: don't decref used object

In the unlikely case of a allocation error we will still use the
existing object so it should not be decref and freed.

doc: some more info about alert format

doc: document target keyword

alert-prelude: correctly set Source and Target

IDMEF alert contains two entities named Source and Target that are
defined using common language:
* "The Source class contains information about the possible source(s) of
   the event(s) that generated an alert."
* "The Target class contains information about the possible target(s) of
   the event(s) that generated an alert."

Previous alerts event were not following that so we can updated the code
when we know the direction thanks to the metadata field.

alert-prelude: fix warnings on callback type

output-json-alert: output source and target

Use metadata provided information to output the Source and Target
in the definition of IDMEF.

The output is now the following:

  "alert": {
    "action": "allowed",
    "gid": 1,
    "signature_id": 1,
    "rev": 1,
    "signature": "connection to home",
    "category": "",
    "severity": 3,
    "source": {
      "ip": "2001:31d0:000a:f68a:0000:0000:0000:0001",
      "port": 80
    },
    "target": {
      "ip": "2a01:0e34:ee97:b130:c685:08ff:dab3:c9c8",
      "port": 48390
    }

detect-target: introduce new keyword

The target keyword allows rules writer to specify information about
target of the attack. Using this keyword in a signature causes
some fields to be added in the EVE output. It also fixes ambiguity
in the Prelude output.

github: add pull request template

github: add contributing doc

common: sync PROG_VER version with configure.ac

changelog: update for 4.0.0-beta1

rust dns: fixup for nom 3.0

rust: build fixes and nom update

Update nom to ~3.0.

Prefix dependencies with ~, which will allow for newer patch
versions only. Minor version updates should get a test before
using.

Remove Cargo.lock from the repo, but still generate as part
of the vendoring process for release builds. This will ensure
that all users of a particular distribution tarball will be
linking against the same Rust dependencies.

rust: add to features

rust: make clear it's experimental

log: fix mem leak in error path (CID1404888)

doc: document drop-invalid option.

qa: update struct-flags coccinelle test

stream-tcp: use flags field to store inline info

stream-tcp: use flags field to store bypass info

af-packet: warn when tpacket_v3 is used in IPS

Update yaml and add an error message.

stream-tcp: add option to accept invalid packets

Suricata was inconditionaly dropping packets that are invalid with
respect to the streaming engine. In some corner case like asymetric
trafic capture, this was leading to dropping some legitimate trafic.

The async-oneside option did help but this was not perfect in some
real life case. So this patch introduces an option that allow the
user to tell Suricata not to drop packet that are invalid with
respect to streaming.

doc: document filestore update

filestore: avoid open write close sequence

Current file storing approach is using a open file, write data,
close file logic. If this technic is fixing the problem of getting
too much open files in Suricata it is not optimal.

Test on a loop shows that open, write, close on a single file is
two time slower than a single open, loop of write, close.

This patch updates the logic by storing the fd in the File structure.
This is done for a certain number of files. If this amount is exceeded
then the previous logic is used.

This patch also adds two counters. First is the number of
currently open files. The second one is the number of time
the open, write, close sequence has been used due to too much
open files.

In EVE, the entries are:
 stats {file_store: {"open_files_max_hit":0,"open_files":5}}

filestore: add option to disable meta file writing

As the fileinfo entry is containing the file_id it is enough to
have this entry to link the extracted file with metadata.

rust/nfs/files: no longer Option/Box

rust/nfs: move files into tx type data

rust/nfs: add more record types

rust/nfs: NFSv3 parser, logger and detection

rust: bindings: improve generator script

rust/core: add file tx API call

rust: filetracker API

Initial version of a filetracker API that depends on the filecontainer
and wraps around the Suricata File API in C.

The API expects chunk based transfers where chunks can be out of order.

rust: filecontainer API

Wrapper around Suricata's File and FileContainer API. Built around
assumption that a rust owned structure will have a
'SuricataFileContainer' member that is managed by the C-side of
things.

rust/json: expose json_boolean

rust: dns: add log filtering on rrtype

While the filtering is still configured in C, the filtering
flags are passed into Rust so it can determine if a record
should be logged or not.

rust: use LoggerFlags type to track logged state

rust: lua support for DNS based Rust

Uses Rust wrappers around Lua to populate Lua
data structures.

rust: lua wrapper

Rust wrapper for working with lua state.

rust: DNS app-layer.

A DNS application layer in Rust. This is different than the
C based one, as it is partially stateless by not matching
up responses to replies.

rust: dns: nom DNS parsers

rust: wrapper around C logging, and "context"

Where the context is a struct passed from C with pointers
to all the functions that may be called.

Instead of referencing C functions directly, wrap them
in function pointers so pure Rust unit tests can still run.

rust: generate headers as part of build

rust: c header generator

rust: add libjansson wrapper for rust

rust: example of how an app-layer may be initialized

Also shows basic usage of the configuration API from Rust.

rust: stub out configuration access functions

rust: stub out logging from rust

travis: enable a rust build

rust: hook rust into the build

Rust is currently optional, use the --enable-rust configure
argument to enable Rust.

By default Rust will be built in release mode. If debug is enabled
then it will be built in debug mode.

On make dist, "cargo vendor" will be run to make a local copy
of Rust dependencies for the distribution archive file.

Add autoconf checks to test for the vendored source, and if it
exists setup the build to use the vendored code instead of
fetching it from the network.

Also, as Cargo requires semantic versioning, the Suricata version
had to change from 4.0dev to 4.0.0-dev.

rust: add rust skeleton tree

stream: suppress GAP notice message

netmap: minor output cleanup

stream: minor output cleanup

flow-hash: optimize to avoid branch misses

Profiling showed a lot of branch misses in flow hashing. Restructure
code to avoid branching.

dns: accept gaps in TCP DNS

On gap notification a flag is set, on the next call the input
data is reprobed to make sure it can be processed.

app-layer: notify parsers of gaps if enabled

A parser can now set a flag that will tell the application
layer that it is capable of handling gaps. If enabled, and a
gap occurs, the app-layer needs to be prepared to accept
input that is NULL with a length, where the length is the
number of bytes lost. It is up to the app-layer to
determine if it can sync up with the input data again.

stream/async: more liberal RST acceptance

stream/async: improvements for IPS

Initialize midstream with async if enabled. Unset async on seeing
bidirectional traffic.

If only async-oneside is enabled, set ASYNC flag on session creation
when receiving a SYN packet.

Let last_ack stay in sync with next_seq so that various checks work
better.

output/streaming: fixes and redo tcp logging

Fix HTTP body logging.

Redo TCP data logging based on the streaming API.

stream: introduce optional 'log' progress tracker

For logging streaming TCP data so far the individual segments where
used. However since the last big stream changes, the segments are
no longer the proper place for this. Segments can now have overlaps
etc.

This patch introduces a new tracker. Next to the existing 'app' and
'raw' trackers, the new tracker is 'log'. When the TCP logging is
used, a flag in the config is set and the log tracker is used to
determine how much of the stream window can be moved.

streaming/lua: add direction indication to streamer

Call SCStreamingBuffer as follows:

    data, sb_open, sb_close, sb_ts, sb_tc = SCStreamingBuffer()

sb_ts and sb_tc are bools indicating the direction of the data.

luajit: cleanup states before return to pool

streaming: small code cleanup

lua/streaming: fix http body logging

flow-worker: improve no-flow case

detect-dns-query: use unit test macros

detect/file: cleanups

TX id is enfored in the engine, so the keywords don't need to.

Unify detect file engines.

rules: add missing classtypes for event.rules

output-tx: small cleanups and scan-build suppression

profiling: fix const compiler warnings

unix socket: improve runmode handling

Improve output of unix mode in --list-runmodes

Honor the runmode commandline setting. Supported are 'single'
and 'autofp', with the latter still the default.

unix-socket: fix minor memleak

log-tlsstore: fix error handling

In case of realloc error, the length of the encoding buffer was not
reset and this could result in trying to write to NULL pointer.

doc: rephrase nocase placement explanation

flow: enforce 51 bits id globally

lua: add SCFlowId for getting the flow id

bug 2113: fix live modes

dns: fix log filtering

Previously only a subset of the records could be selected
in custom. Now allow any to be selected.

stream: single GAP check

Move all GAP checks into CheckGap. Remove seg_list based check.
Also remove seg_list == NULL check to make sure the Gap check is
done on an empty list as well.

Improve next_seq < last_ack check, but add data beyond gap check.

doc: fix doc links for http keywords

doc: flowints formatting cleanup

doc: move parts out of snort difference doc

Move generic keyword descriptions to the keyword documentation.

doc: removing (replaced) snort-compatibility.rst

snort-compatibility.rst replaced by differences-from-snort.rst

doc: replacing snort-compatibility link

The snort-compatibility.rst document is being replaced by
differences-from-snort.rst. This commit updates the link.

doc: overhaul of the snort-compatibility document

This is intended to replace the existing 'snort-compatibility.rst'
document.
Based on "The Suricata Rule Writing Guide for The Snort Expert"
2016 SuriCon talk.

bug 2113: unix-socket start up race

app-layer: optimize many-tx case

output: tx logging optimizations

tests: update tests for app-layer changes

app-layer API optimizations and cleanups

file: fix pruning for parallel files

Allow pruning of random files, not just list head.

file: fix storing parallel files

When looping available files 'flags' misuse would lead to all files
being closed after the first close.

This patch separates per file and per call flags.

file: update loops to account for parallel files