BUG/MAJOR: tcp: only call registered actions when they're registered

Commit cc87a11 ("MEDIUM: tcp: add register keyword system.") introduced
the registration of new keywords for TCP rulesets. Unfortunately it
replaced the "accept" action with an unconditionnal call to the rule's
action function, resulting in an immediate segfault when using the
"accept" action in a TCP ruleset.

This bug reported by Baptiste Assmann was introduced in 1.6-dev1, no
backport is needed.

MEDIUM: stream-int: pause the appctx if the task is woken up

If we're going to call the task we don't need to call the appctx anymore
since the task may decide differently in the end and will do the proper
thing using ->update(). This reduces one wake up call per session and
may go down to half in case of high concurrency (scheduling races).

MEDIUM: applet: make the applets only use si_applet_{cant|want|stop}_{get|put}

The applets don't fiddle with SI_FL_WAIT_ROOM anymore, instead they indicate
what they want, possibly that they failed (eg: WAIT_ROOM), and it's done() /
update() which finally updates the WAIT_* flags according to the channels'
and stream interface's states. This solves the issue of the pauses during a
"show sess" without creating busy loops.

MINOR: stream-int: add two flags to indicate an applet's wishes regarding I/O

Currently we have a problem. There are some cases where a sleeping applet
is not woken up (eg: show sess during an injection). The reason is that
the applet is marked WAIT_DATA and is not woken up when WAIT_ROOM leaves,
because we wait for both flags to be cleared in order to call it.

And if we wait for either flag, then we have the opposite situation, which
is that we're not waiting for room in the output buffer so we're spinning
calling the applet to do nothing.

What is missing is an indication of what the applet needs. Since it only
manipulates the WAIT_ROOM/WAIT_DATA which are overwritten later, that cannot
work. In the case of connections, the problem doesn't happen because the
connection maintains these extra states. Ideally we'd need to have similar
states for each appctx and to store those information there. But it would
be overcomplicated given that an applet doesn't exist alone without a
stream-int, so we can safely put these information into the stream int and
make the code simpler.

With this patch we introduce two new flags in the stream interface :
  - SI_FL_WANT_PUT : the applet wants to put something into the buffer
  - SI_FL_WANT_GET : the applet wants to get something from the buffer

We also have the new functions si_applet_{stop|want|cant}_{get|put}
to make the code look similar to the connection code.

For now these flags are not used yet.

MAJOR: stream: do not allocate request buffers anymore when the left side is an applet

We used to allocate a request buffer so that we could process applets
from process_stream(), and this was causing some trouble because it was
not possible for an analyzer to return an error to an applet, which
we'll need for HTTP/2. Now that we don't call applets anymore from
process_stream() we can simplify this and ensure that a response is
always allocated to process a stream.

MEDIUM: applet: centralize the call to si_applet_done() in the I/O handler

It's much easier to centralize this call into the I/O handler than to
do it everywhere with the risk to miss it. Applets are not allowed to
unregister themselves anyway so their SI is still present and it is
possible to update all the context.

MEDIUM: dumpstats: don't unregister the applet anymore

Let the session do the job, the applet I/O handler doesn't have to unregister
itself.

MAJOR: stream: use a regular ->update for all stream interfaces

Now si->update() is used to update any type of stream interface, whether
it's an applet, a connection or even nothing. We don't call si_applet_call()
anymore at the end of the resync and we don't have the risk that the
stream's task is reinserted into the run queue, which makes the code
a bit simpler.

The stream_int_update_applet() function was simplified to ensure that
it remained compatible with this standardized calling convention. It
was almost copy-pasted from the update code dedicated to connections.
Just like for si_applet_done(), it seems that it should be possible to
merge the two functions except that it would require some slow operations,
except maybe if the type of end point is tested inside the update function
itself.

MAJOR: applet: now call si_applet_done() instead of si_update() in I/O handlers

The applet I/O handlers now rely on si_applet_done() which itself decides
to wake up or sleep the appctx. Now it becomes critical that applte handlers
properly call this on every exit path so that the appctx is removed from the
active list after I/O have been handled. One such call was added to the Lua
socket handler. It used to work without it probably because the main task is
woken up by the parent task but now it's needed.

MEDIUM: stream-int: add a new function si_applet_done()

This is the equivalent of si_conn_wake() but for applets. It will be
called after changes to the stream interface are brought by the applet
I/O handler. Ultimately it will release buffers and may be even wake
the stream's task up if some important changes are detected.

It would be nice to be able to merge it with the connection's wake
function since it mostly manipulates the stream interface, but there
are minor differences (such as how to enable/disable polling on a fd
vs applet) and some specificities to applets (eg: don't wake the
applet up until the output is empty) which would require abstract
functions which would slow down everything.

MEDIUM: applet: implement a run queue for active appctx

The new function is called for each round of polling in order to call any
active appctx. For now we pick the stream interface from the appctx's
owner. At the moment there's no appctx queued yet, but we have everything
needed to queue them and remove them.

MEDIUM: applet: add basic support for an applet run queue

This will be needed so that we can schedule applets out of the streams.
For now nothing calls the queue yet.

REORG: stream-int: create si_applet_ops dedicated to applets

These functions are dedicated to applets so that we don't use the default
ones anymore in this case.

CLEANUP: applet: rename struct si_applet to applet

Since this one does not depend on stream_interface anymore, remove the
"si_" prefix.

REORG: applet: move the applet definitions out of stream_interface

We're tidying the definitions so that appctx lives on its own. A new
set of applet.h files has been added for this purpose.

MEDIUM: applet: make the applet not depend on a stream interface anymore

Now that applet's functions only take an appctx in argument, not a
stream interface. This slightly simplifies the code and will be needed
to take the appctx out of the stream interface.

MINOR: applet: add a new "owner" pointer in the appctx

This pointer indicates what stream-interface the appctx belongs to, just
like we have for the connections.

MEDIUM: stats: Differentiate between DRAIN and DRAIN (agent)

Differentiate between DRAIN and DRAIN (agent) when reporting stats.
This is consistent with the distinction made between DOWN and DOWN (agent).

Signed-off-by: Simon Horman <horms@verge.net.au>

MEDIUM: stats: Only report drain state in stats if server has SRV_ADMF_DRAIN set

There are some similarities between a weight of zero and the
administratively set drain state: both allow existing connections
to continue while not accepting any new ones.

However, when reporting a server state generally a distinction is made
between state=UP,weight=0 and state=DRAIN,weight=*. This patch makes
stats reporting consistent in this regard.

This patch does not alter the behaviour that if a server's weight
is zero then its stats row is blue when accessed via HTML. This remains
the case regardless of if the state is UP or DRAIN.

Signed-off-by: Simon Horman <horms@verge.net.au>

MEDIUM: stats: Separate server state and colour in stats

There is a relationship between the state and colour of a server in
stats, however, it is not a one-to-one relationship and the current
implementation has proved fragile.

This patch attempts to address that problem by clearly separating
state and colour.

A follow-up patch will further distinguish between DRAIN states
and DRAINING colours.

Signed-off-by: Simon Horman <horms@verge.net.au>

MEDIUM: stats: Add enum srv_stats_state

Add an enumeration to make the handling of the states of servers
in status messages somewhat clearer.

This is the first of a two-step attempt to disentangle the state and
colour of status information. A subsequent patch will separate state
colours from the states themselves.

This patch should not make any functional changes.

Signed-off-by: Simon Horman <horms@verge.net.au>

DOC: Fix L4TOUT typo in documentation

Fix documentation typo. L4TMOUT->L4TOUT.

BUG/MEDIUM: http: properly retrieve the front connection

Commit 350f487 ("CLEANUP: session: simplify references to chn_{prod,cons}(&s->{req,res})")
introduced a regression causing the cli_conn to be picked from the server
side instead of the client side, so the XFF header is not appended anymore
since the connection is NULL.

Thanks to Reinis Rozitis for reporting this bug. No backport is needed
as it's 1.6-specific.

DOC: update the entities diagrams

The recent changes were significant enough to warrant an update to the
entities diagram. It tries to be accurate, though it doesn't represent
applets.

BUG/MEDIUM: stream-int: always reset si->ops when si->end is nullified

It happened after changing the stream interface deinitialization
sequence that we got random crashes with si_shutw() being called
on NULL si->end. The reason was that si->ops was not reset after
a call to si_release_endpoint() which is sometimes called directly.

Thus we now move the resetting of si->ops just after any si->end
assignment. It happens that si_detach() is now just the same as
si_release_endpoint() and stream_int_unregister_handler(). Some
cleanup will have to be performed there.

It's not sure whether this problem can impact 1.5 since in 1.5
applets are part of the default embedded stream handler. The only
way it could cause some trouble is if it's used with a connection,
which doesn't seem possible at first glance.

BUG/MAJOR: tcp/http: fix current_rule assignment when restarting over a ruleset

Commit bc4c1ac ("MEDIUM: http/tcp: permit to resume http and tcp custom
actions") introduced the ability to interrupt and restart processing in
the middle of a TCP/HTTP ruleset. But it doesn't do it in a consistent
way : it checks current_rule_list, immediately dereferences current_rule,
which is only set in certain cases and never cleared. So that broke the
tcp-request content rules when the processing was interrupted due to
missing data, because current_rule was not yet set (segfault) or could
have been inherited from another ruleset if it was used in a backend
(random behaviour).

The proper way to do it is to always set current_rule before dereferencing
it. But we don't want to set it for all rules because we don't want any
action to provide a checkpointing mechanism. So current_rule is set to NULL
before entering the loop, and only used if not NULL and if current_rule_list
matches the current list. This way they both serve as a guard for the other
one. This fix also makes the current rule point to the rule instead of its
list element, as it's much easier to manipulate.

No backport is needed, this is 1.6-specific.

BUG/MEDIUM: init: don't limit cpu-map to the first 32 processes only

We have to allow 32 or 64 processes depending on the machine's word
size, and on 64-bit machines only the first 32 processes were properly
bound.

This fix should be backported to 1.5.

BUG/MEDIUM: listener: don't report an error when resuming unbound listeners

Pavlos Parissis reported that a sequence of disable/enable on a frontend
performed on the CLI can result in an error if the frontend has several
"bind" lines each bound to different processes. This is because the
resume_listener() function returns a failure for frontends not part of
the current process instead of returning a success to pretend there was
no failure.

This fix should be backported to 1.5.

CLEANUP: poll: move the conditions for waiting out of the poll functions

The poll() functions have become a bit dirty because they now check the
size of the signal queue, the FD cache and the number of tasks. It's not
their job, this must be moved to the caller. In the end it simplifies the
code because the expiration date is now set to now_ms if we must not wait,
and this achieves in exactly the same result and is cleaner. The change
looks large due to the change of indent for blocks which were inside an
"if" block.

MEDIUM: http: configurable http result codes for http-request deny

This patch adds support for error codes 429 and 405 to Haproxy and a
"deny_status XXX" option to "http-request deny" where you can specify which
code is returned with 403 being the default. We really want to do this the
"haproxy way" and hope to have this patch included in the mainline. We'll
be happy address any feedback on how this is implemented.

BUG/MINOR: ssl: Display correct filename in error message

This patch should be backported to 1.5.

MINOR: stream: pass the pointer to the origin explicitly to stream_new()

We don't pass sess->origin anymore but the pointer to the previous step. Now
it should be much easier to chain elements together once applets are moved out
of streams. Indeed, the session is only used for configuration and not for the
dynamic chaining anymore.

MEDIUM: session: adjust the connection flags before stream_new()

It's not the stream's job to manipulate the connection's flags, it's
more related to the session that accepted the new connection. And the
only case where we have to do it conditionally is based on the frontend
which is known from the session, thus it makes sense to do it there.

MINOR: session: maintain the session count stats in the session, not the stream

This has nothing to do in the stream, as we'll face absurdities when chaining
multiple streams. The session is where it must be accounted for.

CLEANUP: namespaces: fix protection against multiple inclusions

The include file did not protect correctly against multiple inclusions,
as it didn't define the file name after checking for it. That's currently
harmless as the file is only included from .c but that could change.

MINOR: lua: map system integration in Lua

This patch cretes a new Map class that permits to do some lookup in
HAProxy maps. This Map class is integration in the HAProxy update
system, so we can modify the map throught the socket.

MINOR: lua: (req|res)_get_headers return more than one header value

the functions (req|res)_get_headers() return only the last entry
for each header with the same name. This patch fix this behavior.
Each header name contain an array of values.

DOC: lua: some fixes

 - remove trailing spces
 - update fetches ans converters documentation

CLEANUP: stream-int: swap stream-int and appctx declarations

This is just in order to remove two forward declarations of si_applet
and stream_interface that are not needed once properly ordered.

MINOR: peers: no need for setting timeouts / conn_retries in peer_session_create()

For the client side this is done already by stream_new(). For the
server side it will be done when establishing the connection.

MINOR: lua: no need for setting timeouts / conn_retries in hlua_socket_new()

For the client side this is done already by stream_new(). For the
server side it will be done when establishing the connection.

MINOR: lua: minor cleanup in hlua_socket_new()

Just limit the number of dereferences of socket-> since we allocate
the stream at the beginning.

MEDIUM: lua: make use of stream_new() to create an outgoing connection

This significantly simplifies the session management because we don't
have to know all the intimate tricks of setting up a stream and a
session.

MEDIUM: stream: don't rely on the session's listener anymore in stream_new()

When the stream is instanciated from an applet, it doesn't necessarily
have a listener. The listener was sparsely used there, just to retrieve
the task function, update the listeners' stats, and set the analysers
and default target, both of which are often zero from applets. Thus
these elements are now initialized with default values that the caller
is free to change if desired.

CLEANUP: frontend: remove one useless local variable

"p" was a copy of sess->fe which itself is also used. It's used in a
few cases, let's remove it and reduce the code as well.

MEDIUM: frontend: move some remaining stream settings to stream_new()

The auto-forwarding mechanism in case no analyser is set is generic
to the streams. Also the timeouts on the client side are better preset
in the stream initialization as well.

MEDIUM: frontend: don't restrict frontend_accept() to connections anymore

Now it can also initialize streams initiated by applets. This will be
needed for HTTP/2.

MEDIUM: frontend: move the fd-specific settings to session_accept_fd()

The frontend is generic and does not depend on a file descriptor,
so applying some socket options to the incoming fd is not its role.
Let's move the setsockopt() calls earlier in session_accept_fd()
where others are done as well.

MEDIUM: frontend: move some stream initialisation to stream_new()

This is mostly what is related to logging, and which is more of
a stream initialization than anything frontend-specific.

MEDIUM: stream: return the stream upon accept()

The function was called stream_accept_session(), let's rename it
stream_new() and make it return the newly allocated pointer. It's
more convenient for some callers who need it.

MEDIUM: frontend: make ->accept only return +/-1

This function was specified as being able to return 3 states, which had
repercussions to the stream accept function. It was used at the time
when the frontend would do the monitoring itself. This is not the case
anymore, so let's simplify this.

MEDIUM: peers: make use of stream_accept_session()

Instead of going through some obscure initialization sequences, we now
rely on the stream code to initialize our stream. Some parts are still
a bit tricky as we cannot call the frontend's accept code which is only
made for appctx in input. So part of the initialization past the stream
code is what ought to be in the frontend code instead. Still, even
without this, these are 71 lines that were removed.

MEDIUM: stream: also accept appctx as origin in stream_accept_session()

It's likely that the code could be simplified a bit though.

MEDIUM: stream: isolate connection-specific initialization code

In stream_accept_session(), we perform some operations that explicitly
want a connection as the origin, but we'll soon have other types of
origin (eg: applet). Thus change the test to ensure we only call this
code with connections. Additionally, we refrain from calling fe->accept()
if the origin is not a connection, because for now the only fe->accept()
may only use a connection (frontend_accept).

CLEANUP: stream.c: do not re-attach the connection to the stream

This was a leftover from the initial code, it's not needed at all
anymore.

MINOR: session: set the CO_FL_CONNECTED flag on the connection once ready

If we know there's no handshake, we must set the flag on the connection,
it's not the job of the stream initializer to do it.

MEDIUM: peers: initialize the task before the stream

Thanks to this we should be able to make use of stream_accept_session()
now.

MINOR: peers: make use of session_new() when creating a new session

It's better than open-coding it.

MINOR: session: make use of session_new() when creating a new session

It's better than open-coding it.

MINOR: session: introduce session_new()

This one creates a new session and does the minimum initialization.

MEDIUM: peers: move the appctx initialization earlier

The purpose is to initialize the appctx prior to the stream in
order to reuse stream_accept_session().

MINOR: stream-int: make appctx_new() take the applet in argument

Doing so simplifies the initialization of a new appctx. We don't
need appctx_set_applet() anymore.

REORG: session: move the session parts out of stream.c

This concerns everythins related to accepting a new session and
expiring the embryonic session. There's still a hard-coded call
to stream_accept_session() which could be set somewhere in the
frontend, but for now it's not a problem.

MEDIUM: session: remove the task pointer from the session

Now that the previous changes were made, we can add a struct task
pointer to stream_complete() and get rid of it in struct session.

The new relation between connection, session and task are like this :

          orig -- sess <-- context
           |                   |
           v                   |
          conn -- owner ---> task

Some session-specific parts should now move away from stream.

MAJOR: stream: don't initialize the stream anymore in stream_accept

The function now only initializes a session, calls the tcp req connection
rules, and calls stream_complete() to finish initialization. If a handshake
is needed, it is done without allocating the stream at all.

Temporarily, in order to limit the amount of changes, the task allocated
is put into sess->task, and it is used by the connection for the handshake
or is offered to the stream. At this point we set the relation between
sess/task/conn this way :

        orig -- sess  <-- context
         |       ^ +- task -+  |
         v       |          v  |
        conn -- owner       task

The task must not remain in the session and ultimately it is planned to
remove this task pointer from the session because it can be found by
having conn->owner = task, and looping back from sess to conn, and to
find the session from the connection via the task.

MEDIUM: stream: move all the session-specific stuff of stream_accept() earlier

Since the tcp-request connection rules don't need the stream anymore, we
can safely move the session-specific stuff earlier and prepare for a split
of session and stream initialization. Some work remains to be done.

MEDIUM: stream: don't call stream_store_counters() in kill_mini_session() nor session_accept()

This one is not needed anymore since we cannot track the stream counters
prior to reaching these locations. Only session counters may be tracked
and they're properly committed during session_free().

MAJOR: tcp: make tcp_exec_req_rules() only rely on the session

It passes a NULL wherever a stream was needed (acl_exec_cond() and
action_ptr mainly). It can still track the connection rate correctly
and block based on ACLs.

MEDIUM: proto_tcp: track the session's counters in the connection ruleset

The tcp-request connection ruleset now only tracks session counters and
not stream counters. Thus it does not need access to the stream anymore.

MEDIUM: session: update the session's stick counters upon session_free()

Whenever session_free() is called, any possible stick counter stored in
the session will be synchronized.

MEDIUM: streams: support looking up stkctr in the session

In order to support sessions tracking counters, we first ensure that there
is no overlap between streams' stkctr and sessions', and we allow an
automatic lookup into the session's counters when the stream doesn't
have a counter or when the stream doesn't exist during an access via
a sample fetch. The functions used to update the stream counters only
update them and not the session counters however.

REORG: stktable: move the stkctr_* functions from stream to sticktable

These ones are not stream-specific at all and will be needed outside of
stream, so let's move them to stick_tables where struct stkctr is defined.

MINOR: session: add stick counters to the struct session

The stick counters in the session will be used for everything not related
to contents, hence the connections / concurrent sessions / etc. They will
be usable by "tcp-request connection" rules even without a stream. For now
they're just allocated and initialized.

MINOR: session: implement session_free() and use it everywhere

We want to call this one everywhere we have to kill a session so
that future parts we move to the session can be released from there.

MINOR: session: don't rely on s->logs.logwait in embryonic sessions

The embryonic session now only stores the task (to expire the session)
and the stick counters.

MINOR: session: store the session's accept date

Doing so ensures we don't need to use the stream anymore to prepare the
log information to report a failed handshake on an embryonic session.
Thus, prepare_mini_sess_log_prefix() now takes a session in argument.

MINOR: stream: move session initialization before the stream's

In an effort to completely separate stream from session, this patch
further separates the two by initializing the session before the stream.

CLEANUP: stream: don't set ->target to the incoming connection anymore

Now that we have sess->origin to carry that information along, we don't
need to put that into strm->target anymore, so we remove one dependence
on the stream in embryonic connections.

MINOR: stream: provide a few helpers to retrieve frontend, listener and origin

Expressions are quite long when using strm_sess(strm)->whatever, so let's
provide a few helpers : strm_fe(), strm_li(), strm_orig().

MAJOR: sample: pass a pointer to the session to each sample fetch function

Many such function need a session, and till now they used to dereference
the stream. Once we remove the stream from the embryonic session, this
will not be possible anymore.

So as of now, sample fetch functions will be called with this :

   - sess = NULL,  strm = NULL                     : never
   - sess = valid, strm = NULL                     : tcp-req connection
   - sess = valid, strm = valid, strm->txn = NULL  : tcp-req content
   - sess = valid, strm = valid, strm->txn = valid : http-req / http-res

CLEANUP: lua: don't pass http_txn anymore to hlua_request_act_wrapper()

It doesn't use it anymore at all.

MEDIUM: http: remove the now useless http_txn from {req/res} rules

The registerable http_req_rules / http_res_rules used to require a
struct http_txn at the end. It's redundant with struct stream and
propagates very deep into some parts (ie: it was the reason for lua
requiring l7). Let's remove it now.

CLEANUP: lua: remove unused hlua_smp->l7 and hlua_txn->l7

Since last commit, we don't retrieve the HTTP transaction from there
anymore, so these entries can go.

MAJOR: sample: don't pass l7 anymore to sample fetch functions

All of them can now retrieve the HTTP transaction *if it exists* from
the stream and be sure to get NULL there when called with an embryonic
session.

The patch is a bit large because many locations were touched (all fetch
functions had to have their prototype adjusted). The opportunity was
taken to also uniformize the call names (the stream is now always "strm"
instead of "l4") and to fix indent where it was broken. This way when
we later introduce the session here there will be less confusion.

MAJOR: http: move http_txn out of struct stream

Now this one is dynamically allocated. It means that 280 bytes of memory
are saved per TCP stream, but more importantly that it will become
possible to remove the l7 pointer from fetches and converters since
it will be deduced from the stream and will support being null.

A lot of care was taken because it's easy to forget a test somewhere,
and the previous code used to always trust s->txn for being valid, but
all places seem to have been visited.

All HTTP fetch functions check the txn first so we shouldn't have any
issue there even when called from TCP. When branching from a TCP frontend
to an HTTP backend, the txn is properly allocated at the same time as the
hdr_idx.

MINOR: http: create a dedicated pool for http_txn

This one will not necessarily be allocated for each stream, and we want
to use the fact that it equals null to know it's not present so that we
can always deduce its presence from the stream pointer.

This commit only creates the new pool.

MEDIUM: http: move header captures from http_txn to struct stream

The header captures are now general purpose captures since tcp rules
can use them to capture various contents. That removes a dependency
on http_txn that appeared in some sample fetch functions and in the
order by which captures and http_txn were allocated.

Interestingly the reset of the header captures were done at too many
places as http_init_txn() used to do it while it was done previously
in every call place.

CLEANUP: sample: remove useless tests in fetch functions for l4 != NULL

The stream may never be null given that all these functions are called
from sample_process(). Let's remove this now confusing test which
sometimes happens after a dereference was already done.

MEDIUM: session: use the pointer to the origin instead of s->si[0].end

When s->si[0].end was dereferenced as a connection or anything in
order to retrieve information about the originating session, we'll
now use sess->origin instead so that when we have to chain multiple
streams in HTTP/2, we'll keep accessing the same origin.

MINOR: session: add a pointer to the session's origin

A session's origin is the entity that was responsible for creating
the session. It can be an applet or a connection for now.

MEDIUM: stream: move the frontend's pointer to the session

Just like for the listener, the frontend is session-wide so let's move
it to the session. There are a lot of places which were changed but the
changes are minimal in fact.

MEDIUM: stream: move the listener's pointer to the session

The listener is session-specific, move it there.

MEDIUM: stream: allocate the session when a stream is created

This is where we'll put some session-wide information.

MINOR: session: start to reintroduce struct session

There is now a pointer to the session in the stream, which is NULL
for now. The session pool is created as well. Some parts will move
from the stream to the session now.

REORG/MEDIUM: stream: rename stream flags from SN_* to SF_*

This is in order to keep things consistent.

REORG/MAJOR: session: rename the "session" entity to "stream"

With HTTP/2, we'll have to support multiplexed streams. A stream is in
fact the largest part of what we currently call a session, it has buffers,
logs, etc.

In order to catch any error, this commit removes any reference to the
struct session and tries to rename most "session" occurrences in function
names to "stream" and "sess" to "strm" when that's related to a session.

The files stream.{c,h} were added and session.{c,h} removed.

The session will be reintroduced later and a few parts of the stream
will progressively be moved overthere. It will more or less contain
only what we need in an embryonic session.

Sample fetch functions and converters will have to change a bit so
that they'll use an L5 (session) instead of what's currently called
"L4" which is in fact L6 for now.

Once all changes are completed, we should see approximately this :

   L7 - http_txn
   L6 - stream
   L5 - session
   L4 - connection | applet

There will be at most one http_txn per stream, and a same session will
possibly be referenced by multiple streams. A connection will point to
a session and to a stream. The session will hold all the information
we need to keep even when we don't yet have a stream.

Some more cleanup is needed because some code was already far from
being clean. The server queue management still refers to sessions at
many places while comments talk about connections. This will have to
be cleaned up once we have a server-side connection pool manager.
Stream flags "SN_*" still need to be renamed, it doesn't seem like
any of them will need to move to the session.

CLEANUP: lua: get rid of the last two "*hs" for hlua_smp

The two last occurrences were in hlua_fetches_new() and hlua_converters_new().
Now they're called hsmp as in other places.

CLEANUP: lua: rename variable "sc" for struct hlua_smp

It's unclear where this name comes from, but better rename it now to "hsmp"
to be in line with the rest of the code.

CLEANUP: lua: rename last occurrences of "*s" to "*htxn" for hlua_txn

These ones were found in the actions to set the query/path/method/uri.
Where it's used, "s" makes one think about session or something like
this, especially when mixed with http_txn.

CLEANUP: lua: get rid of the last "*ht" for struct hlua_txn.

All other ones are called "htxn", call it similarly in hlua_http_new(),
this will make copy-paste safer.