flowbits: Allow support for flowbit ORing

This patch allows to OR multiple flowbits on isset and isnotset flowbit
actions.

e.g.
Earlier in order to check if either fb1 or fb2 was set, it was required
to write two rules,
```
alert ip any any -> any any (msg:\"Flowbit fb1 isset\"; flowbits:isset,fb1; sid:1;)
alert ip any any -> any any (msg:\"Flowbit fb2 isset\"; flowbits:isset,fb2; sid:2;)
```

now, the same can be achieved with
```
alert ip any any -> any any (msg:\"Flowbit fb2 isset\"; flowbits:isset,fb1|fb2; sid:23;)
```

This operator can be used to check if one of the many flowbits is set
and also if one of the many flowbits is not set.

doc/perf: minor improvements

doc: add performance analysis section

ftp: use switch for ftp commands for style

ftp: FTPGetAlstateProgress for done port commands

For a done transaction with command PORT,
we expect FTP_STATE_FINISHED
and we got FTP_STATE_PORT_DONE instead
which prevented logging of these transactions

We change the order of the evaluations to get the right result

ftp: indent FTPParseResponse again

ftp: FTPParseResponse bufferizes lines

Protects against evasion by TCP packet splitting

The problem arised if the FTP response is split on multiple packets

The fix is to bufferize the content, until we get a complete line

detect: fix insertion in linked list for fast pattern

Make sure we do not add the same list_id twice
by checking at least all the lists with the current priority

conf/datadir: fix possible out of bounds array access

datasets: remove useless variables

datasets: add 'dataset-remove' unix command

datasets: add 'remove' support

thash: add 'remove' support

datasets: improve 'dataset-add' error checking

datasets: fix return values for 'add's

datasets: fix ref cnt handling

Each 'add' and 'lookup' would increment the use_cnt, without anything
bringing it back down.

Since there is no removal yet, nothing is actually affected by it yet.

datasets: silence noisy 'dataset-add' log

build: default to c11 standard

Rearrange pcap includes to fix builds on MinGW

build: don't limit C std to c99 (gnu99)

Now that C11 atomics and thread local storage are supported, the
compiler can figure out what version to use.

configure: check for u_int and friends

fuzz: include pcap headers through suricata-common.h

threads: remove u_long usage

threads: make thread local storage manadatory

Support either the __thread GNUism or the C11 _Thread_local.

Use 'thread_local' to point to the one that is used. Convert existing
__thread user to 'thread_local'.

Remove non-thread-local code from the packet pool code.

atomics: stdatomics.h version of SC_ATOMIC_* wrappers

detect-engine/tags: avoid confusion over data type

atomics: remove unused macros

atomics: add SC_ATOMIC_INITPTR macro

Until now both atomic ints and pointers were initialized by SC_ATOMIC_INIT
by setting them to 0. However, C11's atomic pointer type cannot be
initialized this way w/o causing compiler warnings.

As a preparation to supporting C11's atomics, this patch introduces a
new macro to initialize atomic pointers and updates the relevant callers
to use it.

atomics: change SC_ATOMIC_ADD to 'fetch_add'

Until this point the SC_ATOMIC_ADD macro pointed to a 'add_fetch'
intrinsic. This patch changes it to a 'fetch_add'.

There are 2 reasons for this:

1. C11 stdatomics.h has only 'atomic_fetch_add' and no 'add_fetch'
   So this patch prepares for adding support for C11 atomics.

2. It was not consistent with SC_ATOMIC_SUB, which did use 'fetch_sub'
   and not 'sub_fetch'.

Most callers are not using the return value, so these are unaffected.
The callers that do use the return value are updated.

atomics: avoid unnecessary (direct) CAS use

atomics: remove useless SC_ATOMIC_DESTROY

atomics: remove spinlocked fallback

fuzz: fix applayer eof check segv

fuzz: stop app layer target as Suricata

Before being overwhelmed by successive errors

conf: returns instead of exiting in ConfYamlParse

So that we can keep on fuzzing even on too much recursion

fuzz: add missing debug validation to configure

fuzz: add configure wrapper for oss-fuzz

includes: don't include sys/types.h twice

privs: include headers in suricata-common.h

conf/yaml: include yaml.h after suricata-common.h

doc/install: refer to buster as Debian stable

fuzz/sigpcap: enable all of eve

detect/iponly: fix parsing of '0' valued netmask

util/mem: reduce scope of win32 specific include

util/mem: cleanup by moving atomic from mem hdr

util/mem: move most logic to functions

Reduce macro use and simplify code. Also reduces compiled code
size.

util/mem: remove old debug code for counting allocs

logging: turn SCLog and SCLogErr into funcs

Reduces compiled code size.

common: add ATTR_FMT_PRINTF wrapper

Wraps around __attribute__((format(printf, (x), (y))))

common: use suricata-common.h in more places

common: use WARN_UNUSED macro

detect/mpm: don't process empty store

dns/tests: comment typo fixes

decode: return bool network layer

So that the caller can set the correct event type on error.

decode/hdlc: initial support

decode: single network layer entrypoint

This way new layers can be added in a single place.

decode: create linklayer entry point

Make AF_PACKET and PCAP mode use it.

decode/ieee8021ah: fix possible packet truncation

fuzz/siginit: cleanup detect engine every 1024 runs

app-layer-template: fix log typo

conf/yaml: limit recursion depth while paring YAML

A deeply nested YAML file can cause a stack-overflow while
reading in the configuration to do the recursive parser. Limit
the recursion level to something sane (128) to prevent this
from happening.

The default Suricata configuration has a recursion level of 128
so there is still lots of room to grow (not that we should).

Redmine ticket:
https://redmine.openinfosecfoundation.org/issues/3630

detect/parse: properly free bidir sigs in error path

detect/parse: fix minor memory leak in error path

Only reachable on SCMalloc so should be unlikely to be reached.

fuzz: allow uninitialized stats api

fuzz: remove UNITTEST dependency

Expose UTH flow builder to new 'FUZZ' define as well. Move UTHbufferToFile
as well and rename it to a more generic 'TestHelperBufferToFile'.

This way UNITTESTS can be disabled. This leads to smaller code size
and more realistic testing as in some parts of the code things
behave slightly differently when UNITTESTS are enabled.

dns: improve probe_tcp handling of incomplete data

source/erf: validate record length before read

Check the ERF record length before attempting to read it as
a record length less than the size of the record header
is invalid.

Redmine ticket:
https://redmine.openinfosecfoundation.org/issues/3593

fuzz/sigpcap: initialize empty packet pool

Fixes runs with --enable-debug-validation. The target did not init a
packet pool, so for a tunnel packet would try to get a packet from
an uninitialized pool. In non-debug mode, this silently works by
falling back to a packet from alloc.

    (gdb) bt
    #0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
    #1  0x00007ffff35a6801 in __GI_abort () at abort.c:79
    #2  0x00007ffff359639a in __assert_fail_base (fmt=0x7ffff371d7d8 "%s%s%s:%u: %s%sAssertion `%s' failed.\n%n", assertion=assertion@entry=0x555557fe7260 "!(pool->initialized == 0)",
        file=file@entry=0x555557fe7220 "tmqh-packetpool.c", line=line@entry=253, function=function@entry=0x555557fe7500 <__PRETTY_FUNCTION__.21181> "PacketPoolGetPacket") at assert.c:92
    #3  0x00007ffff3596412 in __GI___assert_fail (assertion=0x555557fe7260 "!(pool->initialized == 0)", file=0x555557fe7220 "tmqh-packetpool.c", line=253,
        function=0x555557fe7500 <__PRETTY_FUNCTION__.21181> "PacketPoolGetPacket") at assert.c:101
    #4  0x00005555577e24be in PacketPoolGetPacket () at tmqh-packetpool.c:253
    #5  0x0000555556914ecd in PacketGetFromQueueOrAlloc () at decode.c:183
    #6  0x00005555569161e1 in PacketTunnelPktSetup (tv=0x555559863980 <tv>, dtv=0x614000068e40, parent=0x61e0000fc080, pkt=0x61e0000fc470 "LL", len=72, proto=DECODE_TUNNEL_IPV4) at decode.c:286
    #7  0x00005555569de694 in DecodeIPv4inIPv6 (tv=0x555559863980 <tv>, dtv=0x614000068e40, p=0x61e0000fc080, pkt=0x61e0000fc470 "LL", plen=72) at decode-ipv6.c:59
    #8  0x00005555569e60b5 in DecodeIPV6ExtHdrs (tv=0x555559863980 <tv>, dtv=0x614000068e40, p=0x61e0000fc080, pkt=0x61e0000fc470 "LL", len=112) at decode-ipv6.c:522
    #9  0x00005555569e846f in DecodeIPV6 (tv=0x555559863980 <tv>, dtv=0x614000068e40, p=0x61e0000fc080, pkt=0x61e0000fc420 "cLL", len=255) at decode-ipv6.c:641
    #10 0x0000555556a032f9 in DecodeRaw (tv=0x555559863980 <tv>, dtv=0x614000068e40, p=0x61e0000fc080, pkt=0x61e0000fc420 "cLL", len=255) at decode-raw.c:70
    #11 0x0000555557659ba8 in DecodePcapFile (tv=0x555559863980 <tv>, p=0x61e0000fc080, data=0x614000068e40) at source-pcap-file.c:412
    #12 0x0000555556573401 in LLVMFuzzerTestOneInput (data=0x613000000047 "\241\262\315\064", size=339) at tests/fuzz/fuzz_sigpcap.c:158
    #13 0x0000555557a4dc66 in main (argc=2, argv=0x7fffffffdfa8) at tests/fuzz/onefile.c:51

That line:

    BUG_ON(pool->initialized == 0);

doc: Update documentation for by_rule and by_both thresholds.

detect/threshold: Add tests for thresholding by_rule and by_both.

detect/threshold: Add a common function to (re)allocate the by_rule threshold table.

Ensure that the by_rule threshold table is initialized if a rule
is thresholded by_rule. Replace manual table reallocaton with calls
to the common function.

detect/threshold: Refactor threshold calculation to handle by_rule and by_both.

The only difference between threshold calculations for by_src/by_dst,
by_rule or by_both is which table stores the DetectThresholdEntry.
Refactor the ThresholdHandlePacket* functions to do table lookup and
storage individually, but calculate thresholds in a common function.

time: Add TIMEVAL_EARLIER and TIMEVAL_DIFF_SEC macros.

Make it easy to compare 'struct timeval's and get their difference.

detect/threshold: Parse by_rule and by_both in rules.

Also add tests for parsing them.

app-layer/proto-detect: minor cleanup

Make sure the mask calculation is u32.

detect/pktvar: fix memory leaks

fuzz: limit input size for protocol detection consistency check

detect/ssl: Fix memory leak in version parsing

This commit fixes a memory leak in the SSL version handling that
manifests when the version identifier is incomplete or incorrect.

fuzz: build compatibility with oss-fuzz flags

ie C define FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION

doc/devguide: Submission and style

This commit adds code submission and coding style guidelines to the
devguide. Most of the material is a straight port from the wiki but
there have been some content modifications and additions.

devguide: include sources in EXTRA_DIST

Required for distcheck to pass, and required to build docs
from a dist archive.

github-ci: on centos-8 build, use distcheck

And verify that man page is built.

github-ci: build documentation on Ubuntu 18.04

github-ci: build documentation on Fedora-31 build

Install sphinx and latex tools to test the building
of documentation on the Fedora 31 build, including
the PDF.

ci: adds a build with make tags

configure: correctly display nss/nspr status

If autodiscovery of libnss was used (default), then the line
 libnss support:                          yes
was never set to no.

Same behavior for libnspr.

Broken by commit 'configure: fix nspr check logic' (7ea269a212a3a2209effc3cc9300873d6a06859e)

flow: cleanup expectations first

Make sure to cleanup expectations for a flow as the first step, before
parts of the flow itself are getting cleaned/freed.

Also indicate use unlikely as flows with expectations should be relatively
rare.

app-layer-expectation: update copyright date

app-layer-expectation: clean expectation at flow end

When a flow timeout, we can have still existing expectations that
are linked to this flow. Given that there is a delay between the
real ending of the flow and its destruction by Suricata, the
expectation should be already honored so we can assume the risk
to clean the expectations that have been triggered by the
to-be-deleted flow.

app-layer-expectation: limit number of expectations

This patch introduces a limitation in term of number of
expectations attached to one IPPair. This is done using
a circle list so we have a FIFO approach on expectation
handling.

Circleq list code is copied from BSD code like was pre existing code
in queue.h.

app-layer-expectation: remove unused parameter

tests/bsize: Fuzzing test case added

This commit adds a test case to validate the issue found during fuzz
testing.

detect/bsize: Ensure numeric values fit

This commit ensures that the numeric values will not exceed the size of
the containers used to hold them.

detect/parse: fix crash on 'internal' keyword use

When keyword __flowvar__postmatch__, an internal keyword, is used
in a rule the 'Setup' func ptr will be NULL. This caused a crash.

fuzz/siginit: fix leak in case of bidir sig

fuzz/siginit: minor improvements

Enable detect engine 'quiet' mode to generate less output.

Set a fake filename so that datarep doesn't hit a reachable assert.

detect/pkt_data: error on unconsumed transforms

If a rule has transforms w/o consuming them (e.g. a content keyword),
don't consider 'pkt_data' valid.

detect/pkt_data: code and test cleanup

detect: more robust against transform issues

In case of transform issues (transform not consumed before pkt_data
for example), the code would hit an ugly BUG_ON.

Address this by a more graceful error message, that will still
invalidate the sig but not crash the engine.

rfb: make sure size calculations do not overflow

Addresses #3570 by extra checking of calculated size requests.

With the given input, the parser eventually arrived at
parser::parse_failure_reason() which parsed from the remaining four
bytes (describing the string length) that the failure string to follow
would be 4294967295 bytes long. While calculating the total size of the
data to request via AppLayerResult::incomplete(), adding the four bytes
for the parsed but not consumed string length caused the u32 length to
overflow, resulting in a much smaller value triggering the bug condition.

This problem was addressed by more careful checking of values in each step
that could overflow: one subtraction, one addition (which could overflow
the usize length values), and a final check to determine whether the result
still fit into the u32 values required by AppLayerResult::incomplete().
If so, we would safely convert the values and pass them to the result type.
If not, we simply return AppLayerResult::err() but do not erroneously and
silently request the wrong amount.

detect/tls: Use pcre_copy_substring to avoid leak

This commit eliminates a memory leak while parsing TLS version
information. The leak was identified through fuzzing.