Defrag engine

Big rewrite of defrag engine to make it more scalable and fix some
locking logic flaws.

Now uses a hash of trackers similar to Flow and Host hashes.

profiling: fix build on older systems

autotools: fix doc install on old systems.

profiling: remove obsolete unit test

pf_ring: set cluster_id even if only one thread is used.

profiling: minor cleanup

profiling: make sure counters are reset after a reload.

profiling: fix memory error in case of rule reload.

Rule profiling update

- Remove usage of counters api.
- Store stats in detect engine thread ctx to remove locking
- Support rule reloads

luajit: add http.uri.raw, cookie, ua, headers, headers.raw buffers.

Fix build if luajit is not available.

defrag: don't return after a cleaning.

This patch changes the policy of the timeout function by cleaning
every timeouted trackers.
Previous code was only freeing the first tracker and this was resulting
in calling the timeout function continuously. One of my previous patch
has modified the function to avoid to run it more than twice a second.
But as it was not taken into account the fact only the first tracker was
freed, the result was that a lot of tracker could not be allocated.

luajit: support http.request_body (http_client_body) and http.response_body (file_data/http_server_body).

luajit: clean up initialization

Install documentation with 'make install'.

pool: rename Free function to Cleanup

This patch renames Free functions to Cleanup as the free is made
by the pool system.

defrag: don't use message for repetitive error

When nothing can be fetch from the pool, this can repeat frequently.
Thus displaying a message in the log will not help. This patch
uses a counter instead of a log message. As this is a sort of memcap
this is conformed to what is done for other issues of the same type.

SC_LOG_ERROR is not an error.

Fix warning about unused return of SC_ATOMIC func.

Fix invalid usage of operator.

freebsd: fix warning about redeclaration.

freebsd: fix warning

ipfw: avoid critical error for broadcast

In some setup, suricata may receive broadcast packets and the call
to sendto may fail if the wrong interface is choosen by kernel.
This patch change the error treatment to avoid to leave when
this problem occurs.

ipfw: add missing include

autotools: fix default path for magic file.

freebsd: fix function usage.

The unlock function was not correctly used in error treatment.

Do not trim the FCS, pcaps converted to ERF will have have an FCS.

af-packet: fix looping in ring buffer.

A crash can occurs in the following conditions:
 * Suricata running in other mode than "workers"
 * Kernel fill in the ring buffer
Under this conditions, it is possible that the capture thread reads
a packet that has not yet released by one of the treatment threads
because there is no modification done on the ring buffer entry when
a packet is read. Doing, this it access to memory which can be
released to the kernel and modified. This results in a kind of memory
corruption.

This bug has only been seen recently and this has to be linked with the
read speed improvement recently made in AF_PACKET support.

The patch fixes the issue by modifying the tp_status bitmask in the
ring buffer. It sets the TP_STATUS_USER_BUSY flag when it is confirmed
that the packet will be treated. And at the start of the read, it exits
from the reading loop (returning to poll) when it reaches a packet with
the flag set. As tp_status is set to 0 during packet release the flag
is destroyed when releasing the packet.

Regarding concurrency, we've got a sequence of modification. The
capture thread read the packet and set the flag, then it passes the
queue and the packet get processed by other threads. The change on
tp_status are thus made at different time.

Regarding the value of the flag, the patch uses the last bit of
tp_status to avoid be impacting by a change in kernel. I will
propose a patch to have TP_STATUS_USER_BUSY included in kernel
as this is a generic issue for multithreading application using
AF_PACKET mechanism.

luajit: add http.uri and http.request_line buffers.

luajit: fix filtering payload or pkt when not available yet

luajit: force scripts to have 'init' function that returns a table of 'needs' such as packet or payload.

Update changelog for 1.4beta1

pool: improve error handling

Error handling during Pool creation was not perfect as a PoolBucket
could leak.

Make sure defrag pool sizes are not initialized to 0, see #540.

tls: fix error handling

Handling of error case was correct as pointed out by Coverity
717439.

tls: avoid double close.

This should fix issue 717441 reported by Coverity.

defrag: be sure to output NULL tracker

Coverity 720337 pointed out a use after free. We can't be dependent
to HashListTableAdd outputting a NULL tracker.

Fix coverity warnings 718636 and 718635

The result of the swap was not checked.

defrag: fix potential use after free.

Coverity pointed out that PoolReturn is almost like free and detected
a use after free when accessing to tracker->af (issue 720339).
This patch fixes this by storing the value in a local variable.

defrag: avoid to run cleaning repetitively

af-packet: handle possible exit of capture loop.

If a capture loop does exit, the thread needs to start without
synchronization with the other threads. This patch fixes this
by resetting the turn count on the peerslist structure and
adding a test on this condition in the wait function.

af-packet: fix kernel offset issue

It seems that, in some case, there is a read waiting but the
offset in the ring buffer is not correct and Suricata need to
walk the ring to find the correct place and make the read.

af-packet: fix emergency mode

This patch fixes emergency mode by setting the variable even if we
have a non kernel checksum check. It also does a call to
AFPDUmpCounters() as it seems to improve thing to do it ASAP.

af-packet: implement late open

This patch implements "late open". On high performance system, it
is needed to create the AF_PACKET just before reading to avoid
overflow. Socket creation has to be done with respect to the order
of thread creation to respect affinity settings.
This patch adds a counter to AFPPeer to be ale to synchronize the
initial socket creation.

af-packet: improve logged messages.

af-packet: rework socket transition phase.

Suricata was not able to start cleanly in AF_PACKET with default
suricata.yaml file if there was no eth1 on the system. This patch
fixes this issue and rework the socket transition phase to fix
some serious issues (file descriptor leak) found when fixing this
problem.
Every 20 seconds it displays a message to the user to warn him about
the interface not being accessible:
  [ERRCODE: SC_ERR_AFP_CREATE(196)] - Can not open iface 'eth1'

af-packet: ring mode is not optionnal in AFPReadFromRing

Fix 'no effect' check in timestamp print logic. Coverity 717437.

Check response headers in custom http logging before using them. Coverity 717436.

decode: use pointer inside packet area as param

DecodeTeredo, DecodeIPv6InIPv6 and DecodeIPv4inIPv6 were calling
DecodeTunnel with packet being a pseudo packet and data being
data from initial packet:
        DecodeTunnel(tv, dtv, tp, start, blen,
                     pq, IPPROTO_IPV6);
In decoding functions, arithmetic was done on pkt to set some values?
It was resulting in field of packet  pointing outside of the scope of
packet data.
This patch switch to what has been done in DecodeGre(), I mean:
        DecodeTunnel(tv, dtv, tp, GET_PKT_DATA(tp),
                     GET_PKT_LEN(tp), pq, IPPROTO_IP);
Data buffer is then relative to the packet and the arithmetic is
correct.

affinity: drop capability after setting thread prio

Setting thread priority can require privilege if a low nice value
has to be set up.

affinity: add call to setup function in threads

Threads created through TMThreadSpawn need to call the affinity
function by themselves.

affinity: tag management threads as such

The management threads were not tagged for CPU affinity and thus
the setting was not applied.

affinity: add log message

Add threshold.config example to EXTRA_DIST as well.

Add threshold.config file.

This patch adds an example file and modify Makefile to have it
installed by 'make install-conf' command.

Add --enable-luajit option to configure

erf: fix logical operator usage.

Implement logic of luajit keyword to match on full packet data and/or payload.

Thread local ctx for detection keywords

Some detection keywords need thread local ctx storage. Example is the
filemagic keyword that has a ctx that is modified with each call. That
is not thread safe. This functionality allows registration of thread
local ctxs so that each detect thread works on it's own copy.

luajit: stub detection keyword

luajit: tell build sys about it

af-packet: fix build on systems without AF_PACKET

doxygen: generate doc for acquisition modules

This patch sets some define to generate doc for the acquisition
modules. It also suppress the doc generation for unittests which
was polluting the output.

pool: update doxygen documentation.

pool: realize a block allocation for preallocated item.

This patch required a evolution of Pool API as it is needed to
proceed to alloc or init separetely. The PoolInit has been changed
with a new Init function parameter.

pool: alloc a single area for all PoolBuckets

As we know the number and the size of PoolBucket, we can simply
allocate a single memory zone.

l3proto: add unit tests

This patch adds a series of unit tests. First two check test the keyword
by checking packet on signatures using it. Last one adds is here to check
that there is no interaction of l3_proto and ip_proto.

sig: add l3_proto keyword

This patch adds a l3_proto keyword to the signature language. It
can be used to specify if the signature has to match on IPv4, IPv6
or both. For example, one can write:
  alert http any any -> any 22 (msg: "HTTP v6"; l3_proto:ip6; sid:14;)

This should close #494.

sig: Add ipv6 and ipv4 to list of protocols

With this patch it is possible to do:
 alert ipv6 any any -> any any
or
 alert ip4 any any -> any any
to match on IPv4 or IPv6 packets.

af-packet: detect MTU mismatch and warn user

If the MTU on the reception interface and the one on the transmission
interface are different, this will result in an error at transmission
when sending packet to the wire.

af-packet: add optional emergency mode

Flush all waiting packets to be in sync with kernel when drop
occurs. This mode can be activated by setting use-emergency-flush
to yes in the interface configuration.

af-packet: reorder socket operation.

This patch moves raw socket binding at the end of init code to
avoid to have a flow of packets reaching the socket before we
start to read them.

The socket creation is now made in the loop function to avoid
any timing issue between init function and the call of the loop.

af-packet: fix runmode name in logging function

af-packet: add doxygen comments

This patch adds doxygen comments to newly introduced function and adds
module AF_PACKET doxygen module with a dedicated AFP peers module.

af-packet: IPS and TAP feature

This patch adds a new feature to AF_PACKET capture mode. It is now
possible to use AF_PACKET in IPS and TAP mode: all traffic received
on a interface will be forwarded (at the Ethernet level) to an other
interface. To do so, Suricata create a raw socket and sends the receive
packets to a interface designed in the configuration file.

This patch adds two variables to the configuration of af-packet
interface:
 copy-mode: ips or tap
 copy-iface: eth1 #the interface where packet are copied
If copy-mode is set to ips then the packet wth action DROP are not
copied to the destination interface. If copy-mode is set to tap,
all packets are copied to the destination interface.
Any other value of copy-mode results in the feature to be unused.
There is no default interface for copy-iface and the variable has
to be set for the ids or tap mode to work.

For now, this feature depends of the release data system. This
implies you need to activate the ring mode and zero copy. Basically
use-mmap has to be set to yes.

This patch adds a peering of AF_PACKET sockets from the thread on
one interface to the threads on another interface. Peering is
necessary as if we use an other socket the capture socket receives
all emitted packets. This is made using a new AFPPeer structure to
avoid direct interaction between AFPTreadVars.

There is currently a bug in Linux kernel (prior to 3.6) and it is
not possible to use multiple threads.

You need to setup two interfaces with equality on the threads
variable. copy-mode variable must be set on the two interfaces
and use-mmap must be set to activated.

A valid configuration for an IPS using eth0 and vboxnet1 interfaces
will look like:

af-packet:
  - interface: eth0
    threads: 1
    defrag: yes
    cluster-type: cluster_flow
    cluster-id: 98
    copy-mode: ips
    copy-iface: vboxnet1
    buffer-size: 64535
    use-mmap: yes
  - interface: vboxnet1
    threads: 1
    cluster-id: 97
    defrag: yes
    cluster-type: cluster_flow
    copy-mode: ips
    copy-iface: eth0
    buffer-size: 64535
    use-mmap: yes

capture: add data release mechanism

This patch adds a data release mechanism. If the capture module
has a call to indicate that userland has finished with the data,
it is possible to use this system. The data will then be released
when the treatment of the packet is finished.

To do so the Packet structure has been modified:
+    TmEcode (*ReleaseData)(ThreadVars *, struct Packet_ *);
If ReleaseData is null, the function is called when the treatment
of the Packet is finished.
Thus it is sufficient for the capture module to code a function
wrapping the data release mechanism and to assign it to ReleaseData
field.

This patch also includes an implementation of this mechanism for
AF_PACKET.

af-packet: improve mmaped running mode.

The mmaped mode was using a too small ring buffer size which was
not able to handle burst of packets coming from the network. This
may explain the important packet loss rate observed by Edward
Fjellskål.
This patch increases the default value and adds a ring-size
variable which can be used to manually tune the value.

af-packet: delete design comments

Make sure we never underflow len in DetectLoadSigFile

Add counters for IPv4 in IPv6 and IPv6 in IPv6

file: convert filesize to new FileMatch api.

stream/app layer: call new Truncate callback for data gap case as well.

stream/app layer: add Truncate app layer callback that is called if stream depth is reached. Use it to trunc open files in HTTP.

file: implement filesize keyword. #489.

detection engine port api unittests cleanup

Create separate detect API call (FileMatch) for file detection keywords. #531.

tls-log: add protocol version to log message.

fix regression (clobbered register; redmine #534)

spelling corrections documented in redmine bug#533

rule reloads: don't lock up main thread so clean shutdown is impossible

pcap: fix compilation on old libpcap

tm-thread: suppress rarely used variable.

Convert to atomic and disable check on HTP config change.

This patch converts the series of variable to an atomic.

Furthermore, as the callbacks are now always run, it is not
necessary anymore to refuse a ruleswap if HTP parameters are
changing.

Get rid of AppLayerHtpRegisterExtraCallbacks

This patch add a early exit condition to the body handling callback.
This permits to avoid to avoid a complex system to handle htp
object change.

Delay Detect threads initialization

This patch modifies the init of Detect threads. They are now started
with a dummy function and their initialisation is done after the
signatures are loaded. Just after this, the dummy function is switched
to normal one.

In IPS mode, this permit to route packets without waiting for the
signature to start and should fix #488.

Offline mode such as pcap file don't use this mode to be sure to
analyse all packets in the file.

The patch introduces a "delayed-detect" configuration variable
under detect-engine. It can be used to activate the feature
(set to "yes" to have signature loaded after capture is started).

pcap: handle failure of packet treatment

If the loop is breaked, this means we've got a treatment error. We
don't need to reconnect but we must exit with correct status.

tls: suppress always true condition.

detect-tls: various indent fixes.

And delete a useless FIXME.

tls: store all the certificates chain in the written PEM file.

When using the tls.store command, a dump of all certificates in
the chain is now done on the disk.