detect: fix crash when stream inspect runs on UDP

Certain rules can apply to both TCP and UDP. For example 'alert dns'
rules are inspected against both TCP and UDP. This lead to the
stream inspect engine being called on a UDP packet.

This patch fixes the issue by exiting early from the stream inspect
engine if a) proto is not TCP or b) ssn is not available

Bug #2158.

eve/alert: redo option parsing

Clean up option parsing. Allow options to be disabled as well as
enabled.

E.g.
    metadata: true
    flow: false

The metadata setting will enable all. Then flow is disabled.

doc: info about new config for alert events in EVE

output-json-alert: rename applayer to metadata

doc: add app_proto to alert event

output-json-alert: add app_proto or flow to events

This patch adds a partial flow entry in the alert event
(if applayer or flow is selected) or simply app_proto if
it is not.

app_proto is useful as filter and aggregation field. And
the partial flow entry contains more information about the
proto as well as some volumetry info.

rust: make distcheck fixes

rust: for sclog*, strip nul bytes before logging

rust: safe string handling in logging

In logging (SCLog*), safely convert strings to cstrings instead
of blindly unwrapping them.

Also implement a simple rust logger if the Suricata C context
is not available.

rust/dns: cargo unit test prototype

Do remove compiler warning when building without unit tests.

rust: save cargo and CARGO_HOME to variables

During configure, substitute the path of cargo, as well as the
value of CARGO_HOME as variables. This fixes the case where a
user might do:
  make
  sudo make install
Which will cause the cargo bits to be rebuilt, including
re-downloading external crates.

By saving these to variables we can be sure that the same
values are used during make install as were used during
make which prevents the Rust artifacts from being rebuild
during "sudo make install".

output-json-alert: fallback to payload if stream is void

If stream logging results in no data then we fallback to payload
data to get somethingi that could be interesting  instead of
nothing.

suricata.yaml: add some port variables

These variables are used by Talos ruleset and defining them allow
to get almost all rules of ruleset loaded.

detect-asn1: fix memory leak

util-print: add 0 at end of buffer

Add a 0 at the end of the printed buffer to be sure we terminate
with a 0 to avoid problem when calling strlen().

tunnel: refactor tunnel verdict handling

Observed:

STARTTLS creates 2 pseudo packets which are tied to a real packet.
TPR (tunnel packet ref) counter increased to 2.

Pseudo 1: goes through 'verdict', increments 'ready to verdict' to 1.
Packet pool return code frees this packet and decrements TPR in root
to 1. RTV counter not changed. So both are now 1.

Pseudo 2: verdict code sees RTV == TPR, so verdict is set based on
pseudo packet. This is too soon. Packet pool return code frees this
packet and decrements TPR in root to 0.

Real packet: TRP is 0 so set verdict on this packet. As verdict was
already set, NFQ reports an issue.

The decrementing of TPR doesn't seem to make sense as RTV is not
updated.

Solution:

This patch refactors the ref count and verdict count logic. The beef
is now handled in the generic function TmqhOutputPacketpool(). NFQ
and IPFW call a utility function VerdictTunnelPacket to see if they
need to verdict a packet.

Remove some unused macro's for managing these counters.

nfs: log number of chunks that xfer'd a file

nfs: add nfs to alerts

Also add a single 'applayer' option for alert augmentation that
applies to all app-layers.

nfs: add to fileinfo events

rust/nfs: add (file)handle to log as crc32

travis: set dist to trusty (Ubuntu 14.04).

The default is still 12.04 which is EOL.

rust/dns: pass byte arrays directly to rust/json

Using the json.set_string_from_bytes which will
safely convert the bytes printable ascii string
before logging.

rust/lua: use lua_pushlstring for strings

Lua strings can contain NULLs, and Rust strings are UTF8 which
can also contain NULLs. Use pushlstring so a NULL containing
string can be pushed.

rust/json: only output printable characters

Rust strings are UTF8 and we cannot yet rely on jansson
having json_stringn on all supported OS distributions yet
so sanitize strings to ascii before printing.

Also add set_string_from_bytes which is like set_string, but
accepts a byte array as input.

rust/nfs: fix style warning

nfs: nfs_version keyword

Store nfs version in tx and add keyword to match on it.

eve/nfs: log nfs version

nfs: rename nfs3 to nfs

Since the parser now also does nfs2, the name nfs3 became confusing.
As it's still in beta, we can rename so this patch renames all 'nfs3'
logic to simply 'nfs'.

nfs3: create file tx for read on request

This is done so that we can add creds to it.

nfs3: add readdirplus path

nfs: log more rpc

nfs: split record parsers into different files

nfs3: fill bytes corner case

nfs: fix rust data type declaration

nfs2: basic record parsing and tracking

nfs3: support NFS over UDP

nfs3: probing parsers in both directions

nfs3: search for next record if needed after GAP

rust/nfs: handle GAPs

In normal records it will try to continue parsing.

GAP 'data' will be passed to file api as '0's. New call is used
so that the file API does know it is dealing with a GAP. Such
files are flagged as truncated at the end of the file and no
checksums are calculated.

nfs3: parse mkdir and rmdir request records

app-layer: remove checks

Now that app-layer parser registrations are validated at startup,
a number of runtime checks are no longer necessary. So remove them.

app-layer: detect state registrations are mandatory

app-layer: validate registration

dcerpc/udp: add missing tx support

python: use python path found during configure

Also look for Python under more names. For example, on OpenBSD
if you just install Python 2, you will only get a python2.7
executable.

Fixed small typo: double sudo

stream: don't do protocol detection on gap

A gap notification has no data.

Also, break out the gap handling into its own code block to
simplify the conditional statements.

hyperscan: unittests compiler warning fixes

rust/dns: fix panic on rrnames with bad chars

Check for erros in the UTF-8 conversion, on error, print the
the printable chars as chars, and print non printable chars
as \xHEX.

Redmine issue:
https://redmine.openinfosecfoundation.org/issues/2148

rust/dns: fix tcp message length verification

And add Rust unit tests to check length validation.

Redmine issue 2144:
https://redmine.openinfosecfoundation.org/issues/2144

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