output: cleanups

Preparation of making output type for json logs configurable.

json tls log: rename to output-json-tls

output: check for multiple instances of drop and tls

Both the drop and tls logs are currently not designed to have multiple
instances running. So until that is changed, error out if more than one
instance is started.

json drop log: rename to output-json-drop

json dns: rename output-dnslog -> output-json-dns

json: rename output-httplog -> output-json-http

json outputs: cleanups

Clean up header files and improve memory handling.

jansson file log: make file log module

Turn the libjansson based file logger into a file module, as a child
of eve-log.

tls json: turn into packet logger

Like log-tls, turn the json tls logger into a packet logger as the
protocol parser is not tx aware.

Make it a child of eve-log as well.

output: simple name space support for sub modules

To avoid module name clashes, a submode abc of parent xyz, will now
register itself as xyz.abc.

drop-json: make child of eve-log

Make drop json child of eve-log.

json drop log: move into packet module

Move JSON drop log into a full packet module.

log api: use AppProto instead of uint16_t

log api: convert all names to const

Instead of strdupping all names w/o a need, use const ptrs.

alert json: make child of eve-log

Enable alert json for eve-log by registering the module as a sub-
module of eve-log.

alert-json: make full module out of json alert

Make a full module out of the json alert code in output-json-alert.[ch].

output: sub-module support for other log api's

Packets:
void OutputRegisterPacketSubModule(const char *parent_name, char *name, char *conf_name,
    OutputCtx *(*InitFunc)(ConfNode *, OutputCtx *),
    PacketLogger LogFunc, PacketLogCondition ConditionFunc);

Files:
void OutputRegisterFileSubModule(const char *parent_name, char *name, char *conf_name,
    OutputCtx *(*InitFunc)(ConfNode *, OutputCtx *), FileLogger FileLogFunc);

Filedata:
void OutputRegisterFiledataSubModule(const char *parent_name, char *name, char *conf_name,
    OutputCtx *(*InitFunc)(ConfNode *, OutputCtx *), FiledataLogger FiledataLogFunc);

output: introduce concept of sub-modules

To support the 'eve-log' idea, we need to be able to force all log
modules to be enabled by the master eve-log module, and need to be
able to make all logs go into a single file. This didn't fit the
API so far, so added the sub-module concept.

A sub-module is a regular module, that registers itself as a sub-
module of another module:

    OutputRegisterTxSubModule("eve-log", "JsonHttpLog", "http",
            OutputHttpLogInitSub, ALPROTO_HTTP, JsonHttpLogger);

The first argument is the name of the parent. The 4th argument is
the OutputCtx init function. It differs slightly from the non-sub
one. The different is that in addition to it's ConfNode, it gets
the OutputCtx from the parent. This way it can set the parents
LogFileCtx in it's own OutputCtx.

The runmode setup code will take care of all the extra setup. It's
possible to register a module both as a normal module and as a sub-
module, which can operate at the same time.

Only the TxLogger API is handled in this patch, the rest will be
updated later.

dns-json: turn logger to tx api

Convert Json DNS logger into a Tx Logger API logger.

http-json: separate module using tx api

Turn HTTP json logger into a Tx Logger API logger.

Various compile fixes after rebase with master

json: rebase fixes

- restore json output-file.[ch] as output-json-file.[ch] after rebase conflict
- fix Makefile.am after merge conflict
- some dev-log-api-v4.0 rebase json fallout cleanup

Remaining JSON output pull request comment edits

address most initial JSON pull request comments

add "united" drop JSON log

Add "united" JSON files output

First cut at "united" file log output in JSON

JSON output cleanup

remove unused http JSON code

more output JSON cleanup

remove dead JSON DNS output code

JSON output cleanup

rename alert-json.[ch] output-json.[ch]

fix compile errors w/o libjansson

remove unused JSON TMM_*JSON enumerations

Add support for JSON output to syslog/unix_stream/unix_dgram

Add "united" log to suricata.yaml.in

JSON output cleanup

add united TLS JSON logging

add ICMP type and code support to JSON log

Support for configuration of JSON http output module

Add vlan and pcap_cnt to JSON logs

First cut at united .yaml configuration

beginning of JSON config alignment

move some JSON alert work outside of lock

JSON cleanup

Alert/HTTP/DNS JSON output working with Logstash

nested json alert output

cleanup fallout from upstream merge with alert json work

Change JSON alert syslog level to INFO

fix NULL string into JSON in alert-json

change srcport->sp dstport->dp

Add JSON formatted alert output

stream: add performance output for stream pools

Add info messages at shutdown that give an indication of pool use
for the various segment and chunk pools.

stream: configurable stream chunk prealloc

The stream chunk pool contains preallocating stream chunks (StreamMsg).
These are used for raw reassembly, used in raw content inspection by
the detection engine. The default setting so far has been 250, which
was hardcoded. This meant that in setups that needed more, allocs and
frees would be happen constantly.

This patch introduces a yaml option to set the 'prealloc' value in the
pool. The default is still 250.

stream.reassembly.chunk-prealloc

Related to feature #1093.

stream: silence stream.reassembly.raw message

stream: configurable segment pools

The stream reassembly engine uses a set of pools in which preallocated
segments are stored. There are various pools each with different packet
sizes. The goal is to lower memory presure. Until now, these pools were
hardcoded.

This patch introduces the ability to configure them fully from the yaml.
There can be at max 256 of these pools.

Yaml layout is as follows:

stream:
  reassemble:
    segments:
      - size: 2048
        prealloc: 3000
      - size: 4
        prealloc: 1000
      - size: 1024
        prealloc: 2000

The size is the packet size. The prealloc value indicates how many
segments are set up at startup.

The pools have no limit wrt how many segments can be used of a certain
size. If the engine needs more than the prealloc size, segments are
malloc'd and free'd. The only limit here is the stream.reassemble.memcap.

If the yaml part if omitted, the default values are the same as before.

Feature #1093

log-filestore: convert to FiledataLog API

This patch converts the log-filestore module to use the new
FiledataLog API.

Introduce Filedata Logger API

A new logger API for registering file storage handlers. Where the
FileLog handler is called once per file, this handler will be called
for each data chunk so that storing the entire file is possible.

The logger call in the API is as follows:
    typedef int (*FiledataLogger)(ThreadVars *, void *thread_data,
        const Packet *, const File *, const FileData *, uint8_t flags);

All data is const, thus should be read only. The final flags field
is used to indicate to the caller that the file is new, or if it's
being closed.

Files use an internal unique id 'file_id' which can be used by the
loggers to create unique file names. This id can use the 'waldo'
feature of the log-filestore module. This patch moves that waldo
loading and storing logic to this API's implementation. A new
configuration directive 'file-store-waldo: <filename>' is added,
but the existing waldo settings will also continue to work.

log-filestore: cleanups

Remove unused code.
Make functions static.
Move registration to the bottom.

log-filestore: tag truncated files as such

Tag truncated files as truncated in the same way log-file does.

tx-logger: speed up

By bailing out early in case no logger is enabled for the protocol,
a significant speed up is reached.

app-layer: add logger check to API

The new API call:
    int AppLayerParserProtocolHasLogger(uint8_t ipproto,
                                        AppProto alproto)

Returns TRUE if a logger is registered on the ip/alproto pair, and
FALSE otherwise.

profiling: add logger api labels

log-file: convert to file-logger API

Use file logger API.

Also, check if the protocol is HTTP before getting the HTTP
fields.

Introduce 'file' logging API

This patch introduces a new logging API for logging extracted file info.
It allows for registration of a callback that is called once per file:
when it's considered 'closed'.

Users of this API register their Log Function through:
    OutputRegisterFileModule()

The API uses a magic settings globally. This might be changed later.

log-file: cleanups

Make all functions static.
Move registration to the bottom.

prelude: convert to packet logger API

Convert prelude logger to use the packet logger API.

prelude: fix configure and cleanup

Fixes configure enabling of prelude. CFLAGS is reset, so the previous
adding of -DPRELUDE was nixed. Using AC_DEFINE now.

Cleanups:
- make functions static
- simplify handling of no prelude support
- move registration to the bottom

alert-syslog: convert to packet logger API

Convert Syslog alert logger to packet logger API.

alert-syslog: cleanup

Remove separate ipv4 and ipv6 registration functions.
Make all functions static.
Move registration function to the bottom.
Simplify OS_WIN32 wrappers usage.

alert-pcapinfo: convert to packet logger API

Convert pcap-info to use the packet logger API.

alert-pcapinfo: clean up

Make functions static.
Move registration to the bottom.

alert-debuglog: minor cleanups

Clean up log functions after packet logger conversion. No more
PacketQueue arguments.

alert-debuglog: port to packet logger api

Convert AlertDebugLog to Packet logger API. Convert packet args to
const.

alert-debug log cleanups

Make all funcs but registration static.
Remove stale registation prototypes.
Move registation func to the bottom.

log-tls: convert to packet logger API

This patch converts log-tls to use the packet logger API. The packet
logger API was choosen as the TLS parser is not transaction aware.

To make sure the state is only logged once, the flag
SSL_AL_FLAG_STATE_LOGGED was added to the parser. This flag is checked
by the condition function, and set at the end of the Logger function.

log-tls: clean ups

Make all functions static. Remove separate ipv4 and ipv6 registration
functions. Move register function to the bottom so that we no longer
need function prototype declarations.

dns: convert dns logger to TX logger API

Make sure to use the new logger TX API. For this the transaction
handling was improved as well.

Convert log-drop to packet logger api.

TX logging API: convert HTTP log

Convert the HTTP log to the new TX logging API.

Introduce TX logging API

This patch introduces a new API for logging transactions from
tx-aware app layer protocols. It runs all the registered loggers
from a single thread module. This thread module takes care of the
transaction handling and flow locking. The logger just gets a
transaction to log out.

All loggers for a protocol will be run at the same time, so there
will not be any timing differences.

Loggers will no longer act as Thread Modules in the strictest sense.
The Func is NULL, and SetupOuputs no longer attaches them to the
thread module chain individually. Instead, after registering through
OutputRegisterTxModule, the setup data is used in the single logging
module.

The logger (LogFunc) is called for each transaction once, at the end
of the transaction.

Packet logging API: convert unified2

Convert unified2 alert to new logging API.

Introduce packet logging output API

This patch introduces a new API for outputs that log based on the
packet, such as alert outputs. In converts fast-log to the new API.

The API gets rid of the concept of each logger being a thread module,
but instead there is one thread module that runs all packet loggers.
Through the registration function OutputRegisterPacketModule a log
module can register itself to be considered for each packet.

Each logger registers itself to this new API with 2 functions and the
OutputCtx object that was already used in the old implementation.
The function pointers are:

LogFunc:       the log function

ConditionFunc: this function is called before the LogFunc and only
               if this returns TRUE the LogFunc is called.

For a simple alert logger like fast-log, the condition function will
simply return TRUE if p->alerts.cnt > 0.

no-detect: handle protocols that have no logger

If a protocol parser is active without a logger when detection is
disabled, the transaction handling logic would fail. Now it will
return the proper tx id so we can clean up the complete transactions.

Add --disable-detection configure option

Add --disable-detection configure option to compile Suricata with
detection disabled.

Error out if -s/-S are used with disable detect

When Suricata is started with --disabled-detection, the -s and -S
options make no sense. So error out.

detect-less: disable raw reassembly

When using --disable-detection automatically disable raw stream
reassembly by forcing stream.reassembly.raw to be false.

detect-less: add log only TX handling function

When running w/o detect, TX cleanup handling needs to ignore the
inspect_id as it's only updated by detect.

This patch introduces a new ActiveTx handler for logging only:
AppLayerTransactionGetActiveLogOnly

If --disable-detection is passed on the commandline, this function
is registered.

Update main loop to handle detect-less

Update main startup and shutdown loops to work will when detect
is disabled. In this case de_ctx remains NULL.

update runmodes to handle detect-less

In runmodes setup, consider a NULL de_ctx to mean detect is disabled.

flow-time: handle detect-less case

Flow timeout code keeps track of thread module running detect, and
fails (hard) if it doesn't find it.

This changeset retrieves the global g_detect_disabled and passes
it to the timeout handling code during setup.

Introduce g_detect_disabled global

This global will be set to TRUE if detect is disabled. The reason for
adding a global is that there currently is no clean way to pass
configuration options to management threads.

Add --disable-detection commandline option

Flags the SuriInstance that the detection engine should be disabled.
Actual disabling is not yet implemented.

flow-timeout: change error logic

If FlowForceReassemblyForFlowV2 can't get packets to inject into the
engine, until now it would bail and retry later. In case of resource
starvation issues, this would cause a lot of lock contention, as the
flow manager would try over and over again.

This patch limits FlowForceReassemblyForFlowV2 to one try per flow,
if it fails... bad luck. It will only fail in serious conditions,
which means we must prefer the health of the engine over the proper
inspection of the flow in question.

app-layer-proto: speed up

AppLayer Proto detection code uses a mix of pattern search and
"probing parsers". The pattern search validates potential matches
using a single pattern search algo. The code was using SpmSearch
for this, but this made it inefficient as it builds a BoyerMoore
context for each search. This lead to significant memory pressure,
especially on high speed/bandwidth boxes.

This patch switches the search calls to BoyerMoore and BoyerMoore-
Nocase directly. This can be done as the ctx' were available already.

app-layer-event: refactor

Move app layer event handling into app-layer-event.[ch].
Convert 'Set' macro's to functions.
Get rid of duplication in Set and SetRaw. Set now calls SetRaw.
Fix potentential int overflow condition in the event storage.
Update callers.

app-layer: shrink AppLayerParserState

Change layout to be more efficient, shrinks structure with 8 bytes.

stream: use reassembly.memcap for stream chunks

Use the stream.reassembly.memcap for stream chunks (StreaMsg) as well.

stream: in SACK, always decrease memcap on free

We should always decrease the stream memcap on freeing SACK records.