pfring: compiler warning fixes

lua: extend SCFlowAppLayerProto

Change SCFlowAppLayerProto to return 5 values:
<alproto> <alproto_ts> <alproto_tc> <alproto_orig> <alproto_expect>:

alproto: detected protocol
alproto_ts: detected protocol in toserver direction
alproto_tc: detected protocol in toclient direction
alproto_orig: pre-change/upgrade protocol
alproto_expected: expected protocol in change/upgrade

Orig and expect are used when changing and upgrading protocols. In a
SMTP STARTTLS case, orig would normally be set to "smtp" and expect
to "tls".

eve.flow: log original and expected app_protocols

Log protocols if they are available.

nfq: don't try to verdict detect/log flush pkts

connect/starttls: handle detection corner cases

When switching protocol from http to tls the following corner case
was observed:

 pkt 6, TC "200 connection established"
 pkt 7, TS acks pkt 6 + adds "client hello"
 pkt 8 TC, acks pkt 7
 pkt 8 is where normally the detect on the 200 connection established
       would run however before detection runs the app-layer is called
       and it resets the state

So the issue is missed detection on the last data in the original
protocol before the switch.

Another case was:

TS ->    STARTTLS
TC ->    Ack "STARTTLS data"
         220
TS ->    Ack "220 data"
         Client Hello

In IDS mode, this made a rule that wanted to look at content:"STARTTLS"
in combination with the protocol SMTP 'alert smtp ... content:"STARTTLS";'
impossible. By the time the content would match, the protocol was already
switched.

This patch fixes this case by creating a 'Detect/Log Flush' packet in
both directions. This will force final inspection and logging of the
pre-upgrade protocol (SMTP in this example) before doing the final
switch.

app-layer: protocol change API

Add API calls to upgrade to TLS or to request a protocol change
without a specific protocol expectation.

If the HTTP CONNECT session includes a port on the url, use that to
look up the probing parser during protocol detection. Solves a
missed detection of a SSLv2 session that upgrades to TLSv1. SSLv2
relies on the probing parser which is limited to certain ports.

In case of STARTTLS in SMTP and FTP, the port is hardcoded to 443.

A new event APPLAYER_UNEXPECTED_PROTOCOL is set if there was a
mismatch.

app-layer: add decoder event for missing TLS after STARTTLS

app-layer-ftp: add STARTTLS support

app-layer-ftp: detect FTP alproto when using AUTH TLS

Try to detect FTP using the patterns '220 (' and 'FEAT', since 'USER '
and 'PASS ' are not sent in cleartext when using AUTH TLS.

output-json-tls: log 'from_proto' field

Log the original application level protocol when protocol have been
changed because of STARTTLS, HTTP CONNECT or similar.

app-layer-smtp: add STARTTLS support

app-layer-htp: add HTTP CONNECT support

proto-detect: add debug output

app-layer: support changing flow alproto

Support changing the application level protocol for a flow. This is
needed by STARTTLS and HTTP CONNECT to switch from the original
alproto to tls.

This commit allows a flag to be set 'FLOW_CHANGE_PROTO', which
triggers a new protocol detection on the next packet for a flow.

magic: fix compile warnings

nfq: remove obsolete and broken netfilterforwin support

isdataat: add test for leading space

nflog: compiler warning fix

compiler: more strict compiler warnings

Set flags by default:

    -Wmissing-prototypes
    -Wmissing-declarations
    -Wstrict-prototypes
    -Wwrite-strings
    -Wcast-align
    -Wbad-function-cast
    -Wformat-security
    -Wno-format-nonliteral
    -Wmissing-format-attribute
    -funsigned-char

Fix minor compiler warnings for these new flags on gcc and clang.

detect-parse: improve common parser

In preparation of turning input to keyword parsers to const add
options to the common rule parser to enforce and strip double
quotes and parse negation support.

At registration, the keyword can register 3 extra flags:

    SIGMATCH_QUOTES_MANDATORY: value to keyword must be quoted

    SIGMATCH_QUOTES_OPTIONAL: value to keyword may be quoted

    SIGMATCH_HANDLE_NEGATION: leading ! is parsed

In all cases leading spaces are removed. If the 'quote' flags are
set, the quotes are removed from the input as well.

detect: enforce isdataat:!1,relative earlier

The expression 'isdataat:!1,relative' is used to make sure a match
is at the end of a buffer quite often. This patch optimizes this case
for 'content' followed by the expression. It enforces it by setting
and 'ends with' flag on the content and then taking that flag into
account while doing the pattern match.

detect: more content inspection tests

detect: don't rescan when just distance is used

Content inspection optimization: when just distance is used without
within we don't need to search recursively.

E.g. content:"a"; content:"b"; distance:1; will scan the buffer for
'a' and when it finds 'a' it will scan the remainder for 'b'. Until
now, the failure to find 'b' would lead to looking for the next 'a'
and then for 'b' after that. However, we already inspected the
entire buffer for 'b', so we know this will fail.

detect: content-inspection tests

Add tests for the content inspection engine that count the number
of steps it takes to eval a rule.

detect: avoid needless recursive scanning

Don't recursively inspect a detect list if the recursion
doesn't increase chance of success.

detect: use BIT_U32 macro for content flags

debug: suppress notice message

cleanup: remove unused ringbuffer code

cleanup: remove libpcap < 1 support

configure: remove CentOS5 pkg-config fix

cleanup: from AS_VERSION_COMPARE CentOS5 workaround

detect: update tests that mix state/stream inspect

unittests: add/improve helpers for stream/flow

http_header: enable trailer prefilter engines

Now that the mpm engines run only for the proper 'progress'
value, the trailing headers need their own engine registration.

state: check progress before calling engine

Make sure progress of an inspect engine is available.

detect: improve stateful detection

Now that MPM runs when the TX progress is right, stateful detection
operates differently.

Changes:

1. raw stream inspection is now also an inspect engine

   Since this engine doesn't take the transactions into account, it
   could potentially run multiple times on the same data. To avoid
   this, basic result caching is in place.

2. the engines are sorted by progress, but the 'MPM' engine is first
   even if the progress is higher

   If MPM flags a rule to be inspected, the inspect engine for that
   buffer runs first. If this step fails, the rule is no longer
   evaluated. No state is stored.

detect: change mask logic

Previously the MPM/Prefilter engines would suggest the same rule
candidates multiple times.

For example, while processing the request body, the http headers
would be inspected by MPM multiple times.

The mask check was one way to quickly decide which rules could be
skipped.

Now that the MPM engines normally return a rule just once, this
mask check no longer makes sense. If the rule meets the ip/port/
direction based conditions, it needs to be evaluated if the MPM
said so. Even if not all conditions are yet true.

WIP disable mask as it no longer makes sense

WIP redo mask match

mpm: run engines as few times as possible

In various scenarios buffers would be checked my MPM more than
once. This was because the buffers would be inspected for a
certain progress value or higher.

For example, for each packet in a file upload, the engine would
not just rerun the 'http client body' MPM on the new data, it
would also rerun the method, uri, headers, cookie, etc MPMs.

This was obviously inefficent, so this patch changes the logic.

The patch only runs the MPM engines when the progress is exactly
the intended progress. If the progress is beyond the desired
value, it is run once. A tracker is added to the app layer API,
where the completed MPMs are tracked.

Implemented for HTTP, TLS and SSH.

detect: register progress in inspect engines

Register required progress so we can stop inspecting as soon
as the progress isn't far enough yet.

detect-state: don't use casts to uint

http_uri: unittest cleanup

http_header: add another trailer test

http_header (trailer) test cleanup

ssh: fix test

ssh: fix banner state setting

detect: more detailed state profiling

app-layer: set stream-depth after stream init

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.