pgsql: fix defect found by coverity

Pgsql was using bitwise operations to assign password output config to
its context flags, but mixing that with logic negation of the default
value, resulting in the expressions having a constant value as result.

Bug: #5007

logging: change ownership of application log if needed

When running with privilege dropping, the application log file
is opened before privileges are dropped resulting in Suricata
failing to re-open the file for file rotation.

If needed, chown the application to the run-as user/group after
opening.

Ticker #4523

startup: initialize run as user info sooner

Initialize the run-as user info after loading the config, but
before setting up logging (previously it was done while initializing
signal handlers). This will allow the log file to be given the
correct permissions if Suricata is configured to run as a non-root
user.

dpdk: adjust setting of MTU to the new DPDK API (21.11)

github-ci: use curl -L for npcap: follow redirects

rust/pgsql: convert parsers to nom7 functions

detect: fix possible leak found by coverity

Conditions to create the leak are likely not reachable,
but this is still a bad pattern.

ci: adds scorecard analysis GitHub workflow

pgsql: add initial support

- add nom parsers for decoding most messages from StartupPhase and
SimpleQuery subprotocols
- add unittests
- tests/fuzz: add pgsql to confyaml

Feature: #4241

rust/applayer: add function for upgrading to TLS

smtp: use AppLayerResult instead of buffering

Also, remove tests that check for the removed buffers and any middle
states while parsing and buffering.

Ticket 4907

quic: add quic.ua for matching user agent

quic: log user agent when available

detect/quic: add quic.sni sticky buffer

quic: log sni; reduce number of transactions

Only create transactions for long headers.

Store SNI in tx, log it.

doc/quic: update for new quic.version logic

quic: log version as string

Log as Q043, Q044, Q045, Q046. If the version is not supported/recognized,
log the 4 bytes as hex.

Only log for txs based on long headers.

quic: redo quic.version; parser cleanups

Reimplement quic.version as sticky buffer.

Removed unused parts of the parser.

Set unidirectional tx flag to fix double matching.

doc/quic: Add documentation for QUIC keywords

doc/quic: Add quic to eve json format

quic: Add QUIC App Layer

Parses quic and logs a CYU hash for gquic frames

Doc: Fix typos in documentation of suricata.yaml.

nfs4_records: add unittests

Add unittests for setclientid, readdir records
Task #4866

rust: simplify bits parser annotations

rust/smb: simplify bits parser annotations

rust: add 'bits' combinator to simplify nom bits parsers

Add a specialized version of the 'bits' nom combinator so adding
bits-level parsers does not require type annotations.

detect: do not upgrade base64 decode when fuzzing

As fuzzing will put a very big value, and then
ThreadCtxDoInit will try to allocate it,
ending in out of memory

proto-detect: set flags in packet direction for UDP

proto-detect: fix UDP not setting alproto_ts/tc

This would lead to the `app-layer-protocol` keyword not matching correctly.

detect: xor transform

Ticket: 3285

The xor transform applies xor decoding to a buffer, with a key
specified as an option in hexadecimal. Arbitrary key sizes are
accepted.

detect: adds test with invalid uint mode <<

detect: use generic functions for icode parsing

fuzz: cleans all flow after one run

Makes the fuzz target more stateless

And manages to find bugs on the FlowFree path

fuzz: use parsed rules in sigpcap target

Ticket: 4125

As commit d21a252238fd766d3c2ec4c2d165d429dad0d85a
But for sigpcap target as well

dns: wrap with HAVE_LUA

This is just code style, to minimize the compiled code.

fuzz: enable template protocols

Ticket: 4125

enip: fix too restrictive check in probing parser

As is shown later in the code, enip_len can be
ENIP_LEN_REGISTER_SESSION which is 4, which is
smaller than sizeof(ENIPEncapHdr) which is 24

fuzz: use fuzzing confyaml for protodetect target

As is done for other targets,
so that all app-layer protocols are enabled,
even the ones disabled by default such as enip

And resets protocol detection every time we try
so that probing_parser_toserver_alproto_masks are fresh.

doc/update: mention change of default rule path

doc: update rule section to current default

Update the rule section to better describe whats seen in a default
install of Suricata including a link to the rule management section.

rule-path: always use $localstatedir/lib/suricata/rules

Always use the same path for default-rule-path whether or not
Suricata-Update will be installed as part of the Suricata install or
not.

This provides consistency, and maps better to our recommendation that
Suricata-Update be used to manage rules.

Probably should have been done as part of
55852d0de3151517b6cb22c736cb2de8a893cb11.

Ticket #4912.

telnet: initial support with frames

Bootstrapped using setup script. Basic option parsing for purpose
of tagging frames.

htp: improve request/response size accuracy

htp: implement basic request/response frames

ssl: implement frames for SSLv3 and TLS

smb: use derive AppLayerFrameType

smb: implement frames

SMB1 record parsing code simplification.

Frames:

    nbss.pdu
    nbss.hdr
    nbss.data

    smb1.pdu
    smb1.hdr
    smb1.data

    smb2.pdu
    smb2.hdr
    smb2.data

    smb3.pdu
    smb3.hdr
    smb3.data

The smb* frames are created for valid SMB records.

detect/frames: implement 'frame' keyword

Implement a special sticky buffer to select frames for inspection.

This keyword takes an argument to specify the per protocol frame type:

    alert <app proto name> ... frame:<specific frame name>

Or it can specify both in the keyword:

    alert tcp ... frame:<app proto name>.<specific frame name>

The latter is useful in some cases like http, where "http" applies to
both HTTP and HTTP/2.

    alert http ... frame:http1.request;
    alert http1 ... frame:request;

Examples:

    tls.pdu
    smb.smb2.hdr
    smb.smb3.data

Consider a rule like:

    alert tcp ... flow:to_server; content:"|ff|SMB"; content:"some smb 1 issue";

this will scan all toserver TCP traffic, where it will only be limited by a port,
depending on how rules are grouped.

With this work we'll be able to do:

    alert smb ... flow:to_server; frame:smb1.data; content:"some smb 1 issue";

This rule will only inspect the data portion of SMB1 frames. It will not affect
any other protocol, and it won't need special patterns to "search" for the
SMB1 frame in the raw stream.

detect/frames: limit mixing frames and other detection

Don't allow mixing of payload/stream/tx and frame keywords. Initial
support is only for 'pure' frame inspection.

detect/analyzer: add frame support

detect/engine: support frames

Implement the low level detect engine support for inspecting frames,
including MPM, transforms and inspect API's.

eve/alert: add support for logging frame

If detection was done in a frame, the frame will be added to the
eve.alert output.

eve: implement frame logging

This is mostly to assist development and QA. It produces too much data
for practical use.

cbindgen: ignore frames module

rust: derive macro for app-layer frame type

rust/applayer: create trait for app-layer frame types

app/frames: implement rust API

app-layer: move app_progress forward on errors as well

In case of APP_LAYER_ERROR still move the app_progress forward.
This helps validation of frame offsets and should be harmless
otherwise.

app/frames: initial support

The idea of stream frames is that the applayer parsers can tag PDUs and
other arbitrary frames in the stream while parsing. These frames can then
be inspected from the rule language. This will allow rules that are more
precise and less costly.

The frames are stored per direction in the `AppLayerParserState` and will only
be initialized when actual frames are in use. The per direction storage has a
fixed size static portion and dynamic support for a larger number. This is done
for effeciency.

When the Stream Buffer slides, frames are updated as they use offsets relative
to the stream. A negative offset is used for frames that started before the
current window.

Frames have events to inspect/log parser errors that don't fit the TX model.

Frame id starts at 1. So implementations can keep track of frame ids where 0
is not set.

Frames affect TCP window sliding. The frames keep a "left edge" which
signifies how much data to keep for frames that are still in progress.

app/frames: implement name to id API for frames

stream: add util function to get 'usable' data

ci: do not use ppa for cocci

As this version segfaults

rust/http2: convert parser to nom7 functions (HTTP2 ranges)

rust/http2: convert parser to nom7 functions (HTTP2 core functions)

dpdk: fix received/error counters

tests/pppoe: clean up more tests to use PASS/FAIL macros

pppoe: fix protocol field length variation

Detect when protocol field is not a 16 bit field.
Added tests to prove logic

Ticket: 4810

test/pppoe: refactor to use FAIL/PASS macros

detect-file-data: remove SMTP unittests

These tests are reimplemented as Suricata-verify tests

Task: 4938

output/alert: don't call basic logging twice

Issue: 4106

stream: suppress noisy debug message

stream: fix stream pruning being too aggressive

Pruning of StreamBufferBlocks could remove blocks that fell entirely
after the target offset due to a logic error. This could lead to data
being evicted that was still meant to be processed in theapp-layer
parsers.

Bug: #4953.

stream: debug code for showing segment list state

detect: Avoid recomputing ntohl() in addr match

This commit makes a small optimization when comparing IPv4 and IPv6
addresses by making the host order value invariant and calculating the
value once, before entering the loop.

file: define own variable instead of PATH_MAX

to be used for maximum size of file names,
and not depend on the OS

ssl: fix int warnings

especially increasing padding_len size

smtp: fix int warnings

and explicitly truncating filename's length

app: fix int warnings in generic app files

http: : fix int warnings

Explicitly truncate file names to UINT16_MAX

Before, they got implicitly truncated, meaning a UINT16_MAX + 1
file name, went to 0 file name (because of modulo 65536)

ftp: fix int warnings

Explicitly truncate a file name if it is longer
than UINT16_MAX

log: Coverity REVERSE_INULL warnings

This commit addresses Coverity reported "REVERSE_INULL" warnings.

Issue: 4699

doc: fix typo lenght/length

nfs4_records: add unittests for nom7 parsers

Task #4866

nfs4_records: add missing field to res_sequence_ok()

Missing _seqid in sequence op struct left a trailing four zeros
that are parsed by nfs4_res_compound_command() as a cmd
causing a Switch Error Code

nfs3-records: add unittests to nom7 parsers

Task #4866

nfs3-records: add missing fields and update parsers

Add missing fields to some record structures and
update their respective parsers

nfs2-records: add unittests for nom7 parsers

Task #4866

suricatasc: Handle incomplete/empty recv values

Issue: 4947

Improve handling of values returned by recv. Sometimes, recv returns an
empty string if suricata terminates asynchronously.

nfs2: improve READ parsing

Take fill_bytes into account.

rust/app-layer: expose AppLayerEvent derive macro

Export the AppLayerEvent derive macro so plugin (or library code) can
use it as expected, for example:

use suricata::applayer::AppLayerEvent;

enum MyEvent {
    EventOne,
    EventTwo,
}

rust/derive: make usable from a plugin or lib user

The macro was generating code that references names use the "crate"
prefix which will fail if the macro is used by a library user or plugin.
Dynamically check where we are running an use the correct import paths
as needed.

rust: rename to suricata (from suricata_rust)

Rename the Rust lib to simply "suricata" instead of "suricata_rust".
This allows Rust plugin/library code to use it under the name "suricata"
which is what should be expected.

The name was only "suricata_rust" to prevent on-disk conflict with the C
code, so just rename the file on disk, which doesn't affect how the code
is interacted with from an API layer.

rust: remove feature function-macro

The function macro existed so it would only be enabled on Rust
versions that supported.  Now that our MSRV is 1.41, which is
greater than 1.38 we can assume we always have support for
this macro.

rust: bump MSRV to 1.41.1

Ticket: #4902.
(cherry picked from commit 87f04475aaa75ee205b1b699e59fb2b5ba7ed59f)

rust/http2: use base64 crate for base64 decode

base64: use the Rust base64 encode implementation

Replace our internal base64 implementation with a ffi wrapper
around the Rust implementation provided by an external crate.

eve: use JsonBuilder for encoding base64

Replaces all usages of Base64Encode just before writing to a
JsonBuilder with jb_set_base64 and jb_append_base64.

jsonbuilder: add methods to encode values as base64

Add new methods to set a value as a base64 encoded string of
a byte array. This uses the Rust base64 crate and encodes
directly into the JsonBuilder buffer with no intermediate
buffer required.

jb_set_base64: set a field on an object
jb_append_base64: append a value to an array

app-layer: use StreamSlice as input to parsers

Remove input, input_len and flags in favor of stream slice.

app-layer: add StreamSlice to pass data to parsers

Since object to contain relevant pointer, length, offset, flags to make
it easy to pass these to the parsers.