http2: generic http2_header_blocks

so as not to forget continuation and push promise
when iterating over headers

http2: http.header keyword now works for HTTP2

As well as http.header.raw

http2: http.header_names keyword now works for HTTP2

http2: http.host normalized keyword now works for HTTP2

http2: turn Host header into authority during upgrade

HTTP1 uses Host, but HTTP2 uses rather :authority cf HPACK

http2: better file tracking

If an HTTP2 file was within only ont DATA frame, the filetracker
would open it and close it in the same call, preventing the
firther call to incr_files_opened

Also includes rustfmt again for all HTTP2 files

http2: support deflate decompression

cf #4556

ftp: support per-tx file accounting

smtp: support per-tx file accounting

smb: add debug validation on file counts

smb: count files in tx

http2: support per-tx file accounting

nfs: add debug validation on file counts

nfs: support per-tx file accounting

nfs: don't reuse file transactions

After a file has been closed (CLOSE, COMMIT command or EOF/SYNC part of
READ/WRITE data block) mark it as such so that new file commands on that
file do not reuse the transaction.

When a file transfer is completed it will be flagged as such and not be
found anymore by the NFSState::get_file_tx_by_handle() method. This forces
a new transaction to be created.

http: support per-tx file accounting

filestore: track files getting stored per tx

Avoid evicting a tx before the filedata logger has decided it is
done.

filestore: store chunks in packet direction

Storing too early can lead to files being considered TRUNCATED if the
TCP state is not yet CLOSED when logging is triggered. This has been
observed with FTP-DATA and might also be an issue with simple HTTP.

app-layer/transactions: track files opens and logs

To make sure a transaction is not evicted before all file logging is complete.

eve/files: log in packet direction only

Bug: #3703.

Don't log files too soon.

GRE: Handling pptp without payload

If one of the ppp peers sends a packet with an acknowledge flag,
the ppp payload will be empty and DecodePPP will return TM_ECODE_FAILED.
To handle this case, the packet_length field in the GRE extended header (https://tools.ietf.org/html/rfc2637#section-4.1) is used.
DecodeGRE no longer tries to parse PPP payload if packet_length is zero.

scripts: bundle script for requirements

Add a bundle.sh script to bundle the requirements of libhtp
and suricata-update. This uses a Python like requirements.txt
file to specify the URL to download for libhtp and suricata-update.

doc: Update public-data-sets.rst

Replace dead link

Dataset on ll.mit.edu returns 404. Link updated with a search result of more datasets.

detect-dsize: Add ! operator for dsize matching

smb: get file name in case of chained commands

smb: fix parsing of file deletion over SMB1

smb: recognizes file deletion over SMB2

using set_info_level == SMB2_FILE_DISPOSITION_INFO

ike: use derive macro from app-layer events

modbus: use derive macro from app-layer events

app-layer template: use derived app-layer event

http2: use derived app-layer event

krb5: use derived app-layer event

ntp: use derived app-layer event

rfb: register None for get_event_info/get_event_info_by_id

Implementations are not required if they're just going to return
-1. We allow None to be registered for that.

sip: use derived app-layer event

snmp: use derived app-layer event

ssh: use derived app-layer event

dhcp: use derived app-layer event

smb: use derived get_event_info/get_event_info_by_id

mqtt: derive AppLayerEvent for MQTTEvent

dns: use derive macro for DNSEvent

applayerevent: derive get_event_info and get_event_info_by_id

Add generation of wrapper functions for get_event_info
and get_event_info_by_id to the derive macro. Eliminates
the need for the wrapper method to be created by the parser
author.

rust/applayer: provide generic event info functions

Provide generic functions for get_event_info and
get_event_info_by_id. These functions can be used by any app-layer
event enum that implements AppLayerEvent.

Unfortunately the parser registration cannot use these functions
directly as generic functions cannot be #[no_mangle]. So they
do need small extern "C" wrappers around them.

rust: derive crate: for custom derives

Currently has one derive, AppLayerEvent to be used like:

  #[derive(AppLayerEvent)]
  pub enum DNSEvent {
      MalformedData,
      NotRequest,
      NotResponse,
      ZFlagSet,
  }

Code will be generated to:
- Convert enum to a c type string
- Convert string to enum variant
- Convert id to enum variant

rust/applayer: define AppLayerEvent trait

The derive macro will implement this trait for app-layer
event enums.

macset: adjust test to pass after fix

ci: dummy git configuration for rebase

macset: fix memory size check

flow: be sure to check hash till the end

flow: add comment on flow handling

stream: increase memcap on memory errors

util/streaming: improve error handling

It differentiates memory error than regular ones.

flow: fix a debug assert

As the FlowBypassedTimeout function is interacting with the capture
method it is possible that the return changes between the call that
did trigger the timeout and the actual state (ie if packets arrive
in between the two calls). So we should not use the call to
FlowBypassedTimeout in the assert.

flow: document FlowBypassedTimeout

Main point is to document it is interacting with the capture
layer.

flow: more accurate flow counters

Don't increment the flow timeout counter for flows that are not
really timeout (as use_cnt is non zero). And also don't take into
account bypassed flows in the counter for flow timeout in use.

flow/worker: handle timeout edge case

In the flow worker timeout path it is assumed that we can hand off
flows to the recycler after processing, implying that `Flow::use_cnt` is 0.
However, there was a case where this assumption was incorrect.

When during flow timeout handling the last processed data would trigger a
protocol upgrade, two additional pseudo packets would be created that were
then pushed all the way through the engine packet paths. This would mean
they both took a flow reference and would hold that until after the flow
was handed off to the recycler. Thread safety implementation would make
sure this didn't lead to crashes.

This patch handles this case returning these packets to the pool from
the timeout handling.

flow/worker: set proper end flag

flow/manager: set proper end flag

detect: debug validation for list ids overflows

detect: move init only array to init data

detect/analyzer: use rule style pretty print for patterns

detect/content: generalize pattern pretty printing

detect/profile: add support for tx inspection

Add 'inspect_type' "packet" and "tx" for the two record types. Add more metadata
when available.

detect/analyze: dump patterns facility

Dump all patterns to `patterns.json`, with the pattern, a total count (`cnt`),
count of how many times this pattern is the mpm (`mpm`) and some of the flags.

Patterns are listed per buffer. So payload, http_uri, etc.

detect/content: add some more dsize tests

detect/dsize: set depth flag when applying dsize as depth

detect/analyzer: count mpm with depth, endswith

detect/analyzer: show payload separately in group dumping

detect/analyzer: add icmp to rule group output

detect/analyzer: display per rule prefilter details

detect/analyzer: count prefilter per rule group

detect/analyzer: add per rule mpm block to rules.json

detect/analyzer: support buffer names in sgh dump

flow: determine packet direction once per packet

decode: convert 'action' macros to inline funcs

Make sure most common branch is handled first to assist branch
prediction.

Macros still play a small role to please our 'action' cocci check.

detect/mpm: turn factory array into list

detect/stream: don't run mpm on packet if stream is available

doc: escape dot in pcre

unix-socket: Avoid spurious logs on close

Avoid spurious logs when suricatasc closes connection.

Use SCLogDebug for control connection EOF, and SCLogError for an error.

As Chandan Chowdhury described in redmine 3685. This makes the logging
consistent with the older `if (client->version <= UNIX_PROTO_V1)` block
about 20 lines above, and avoids polluting the logs with
`Unix socket: lost connection with client`.

ci: rebase specified s-v pr

So that CI does not fail, if suricata PR got upgraded in a new
version, but S-V PR did not get upgraded, and S-V changed
in master

dnp3: regenerate object decoding code

Ticket: #4558
So as to avoid intra-structure overflow

dnp3: adds bounds check for prefix chararray

Ticket: #4558
Avoids intra structure overflow

dnp3: use base64 macro in gen script

As is done already in C
cf commit ea0936199d142fc52ec69baf7984cbdd92dd4705

threading: don't pass locked flow between threads

Previously the flow manager would share evicted flows with the workers
while keeping the flows mutex locked. This reduced the number of unlock/
lock cycles while there was guaranteed to be no contention.

This turns out to be undefined behavior. A lock is supposed to be locked
and unlocked from the same thread. It appears that FreeBSD is stricter on
this than Linux.

This patch addresses the issue by unlocking before handing a flow off
to another thread, and locking again from the new thread.

Issue was reported and largely analyzed by Bill Meeks.

Bug: #4478

rust(lint): suppress clippy lints that we should fix

Suppress all remaining clippy lints that we trip. This can be
fixed on a per-lint basis.

rust(lint): remove manual implement of map method

Using `if let` expressions in these cases is better expressed
by the map method, and considered idiomatic Rust for this usage.

rust(lint): map the error instead of using or_else

This is the preffered style and easier to understand the meaning
of the code.

rust(lint): replace push_str of single char to push(<char>)

rust(lint): fix some usages of references

- ref is discouraged for top level variables
- the other borrow is not required

rust(lint): replace checked_mul with saturating_mul

When defaulting checked_mul to u64::max, Rust has a method
that does the same thing called saturating_mul.

rust(lint): removed unused unit () return

This is code that is not needed and is a bit confusing to see.

rust(lint): remove extra parens around bitwise or

This is a readability fix, as on first look they almost look
like a Rust tuple.

rust(lint): remove useless conversions and clones

These add complexity and may not be optimized out by the compiler.

rust(lint): remove useless format calls

In these simple cases to_string() is recommended and likely
performs better as the formatter is not called.

rust(lint): don't use unwrap_or for function calls

Calling a function in unwrap_or causes that function to always
be called even when not needed. Instead use unwrap_or_else with
a closure which will only be called when needed.

rust(lint): fix redundant closures

This lint checks for a closure where a function can be directly
supplied.  Runtime performance is unchanged, but this makes
less work for the compiler.

rust(lint): remove needless borrows

These are needless borrows (references) as the item is already
a reference.

rust: functions that reference raw pointers are unsafe

Based on the Rust clippy lint that recommends that any public
function that dereferences a raw pointer, mark all FFI functions
that reference raw pointers with build_slice and cast_pointer
as unsafe.

This commits starts by removing the unsafe wrapper inside
the build_slice and cast_pointer macros then marks all
functions that use these macros as unsafe.

Then fix all not_unsafe_ptr_arg_deref warnings from clippy.

Fixes clippy lint:
https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref

rust: remove all usage of transmute

All cases of our transmute can be replaced with more idiomatic
solutions and do no require the power of transmute.

When returning an object to C for life-time management, use
Box::into_raw to convert the boxed object to pointer and use
Box::from_raw to convert back.

For cases where we're just returning a pointer to Rust managed
data, use a cast.

output/redis: Fix possible segv