MINOR: peers: now remove the remote connection setup code

The connection is not needed anymore, the backend does the job.

MAJOR: stream: store the target address into s->target_addr

When forcing the outgoing address of a connection, till now we used to
allocate this outgoing connection and set the address into it, then set
SF_ADDR_SET. With connection reuse this causes a whole lot of issues and
difficulties in the code.

Thanks to the previous changes, it is now possible to store the target
address into the stream instead, and copy the address from the stream to
the connection when initializing the connection. assign_server_address()
does this and as a result SF_ADDR_SET now reflects the presence of the
target address in the stream, not in the connection. The http_proxy mode,
the peers and the master's CLI now use the same mechanism. For now the
existing connection code was not removed to limit the amount of tricky
changes, but the allocated connection is not used anymore.

This change also revealed a latent issue that we've been having around
option http_proxy : the address was set in the connection but neither the
SF_ADDR_SET nor the SF_ASSIGNED flags were set. It looks like the connection
could establish only due to the fact that it existed with a non-null
destination address.

MINOR: stream: add a new target_addr entry in the stream structure

The purpose will be to store the target address there and not to
allocate a connection just for this anymore. For now it's only placed
in the struct, a few fields were moved to plug some holes, and the
entry is freed on release (never allocated yet for now). This must
have no impact. Note that in order to fit, the store_count which
previously was an int was turned into a short, which is way more
than enough given that the hard-coded limit is 8.

MINOR: connection: don't use clear_addr() anymore, just release the address

Now that we have dynamically allocated addresses, there's no need to
clear an address before reusing it, just release it. Note that this
is not equivalent to saying that an address is never zero, as shown in
assign_server_address() where an address 0.0.0.0 can still be assigned
to a connection for the time it takes to modify it.

MAJOR: connection: remove the addr field

Now addresses are dynamically allocated when needed. Each connection is
created with src=dst=NULL, these entries are allocated on the fly, and
released when the connection is released.

MEDIUM: connection: make sure all address producers allocate their address

This commit places calls to sockaddr_alloc() at the places where an address
is needed, and makes sure that the allocation is properly tested. This does
not add too many error paths since connection allocations are already in the
vicinity and share the same error paths. For the two cases where a
clear_addr() was called, instead the address was not allocated.

MINOR: connection: create a new pool for struct sockaddr_storage

This pool will be used to allocate storage for source and destination
addresses used in connections. Two functions sockaddr_{alloc,free}()
were added and will have to be used everywhere an address is needed.
These ones are safe for progressive replacement as they check that the
existing pointer is set before replacing it. The pool is not yet used
during allocation nor freeing. Also they operate on pointers to pointers
so they will perform checks and replace values. The free one nulls the
pointer.

MEDIUM: backend: turn all conn->addr.{from,to} to conn->{src,dst}

All reads were carefully reviewed for only reading already checked
values. Assignments were commented indicating that an allocation will
be needed once they become dynamic. The memset() used to clear the
addresses should then be turned to a free() and a NULL assignment.

MINOR: http: convert conn->addr.from to conn->src in sample fetches

These calls are safe because the address' validity was already checked
prior to reaching that code.

MINOR: frontend: switch from conn->addr.{from,to} to conn->{src,dst}

All these values were already checked, it's safe to use them as-is.

MINOR: checks: replace conn->addr.to with conn->dst

Two places will require a dynamic address allocation since the connection
is created from scratch. For the source address it looks like the
clear_addr() call will simply have to be removed as the pointer will
already be NULL.

MINOR: log: use conn->{src,dst} instead of conn->addr.{from,to}

This is used to retrieve the addresses to be logged (client, frontend,
backend, server). In all places the validity check was already performed.

MINOR: sockpair: use conn->dst for the target address in ->connect()

No extra check is needed since the destination must be set there.

MINOR: unix: use conn->dst for the target address in ->connect()

No extra check is needed since the destination must be set there.

MINOR: tcp: replace conn->addr.{from,to} with conn->{src,dst}

Most of the locations were already safe, only two places needed to have
one extra check to avoid assuming that cli_conn->src is necessarily set
(it is in practice but let's stay safe).

MINOR: session: use conn->src instead of conn->addr.from

In session_accept_fd() we'll soon have to dynamically allocate the
address, or better, steal it from the caller and define a strict calling
convention regarding who's responsible for the freeing. In the simpler
session_prepare_log_prefix(), just add an attempt to retrieve the address
if not yet set and do not dereference it on failure.

MINOR: proxy: switch to conn->src in error snapshots

The source address was taken unchecked from a client connection. In
practice we know it's set but better strengthen this now.

MINOR: stream: switch from conn->addr.{from,to} to conn->{src,dst}

No allocation is needed there. Some extra checks were added in the
stream dump code to make sure the source address is effectively valid
(it always is but it doesn't cost much to be certain).

MINOR: htx: switch from conn->addr.{from,to} to conn->{src,dst}

One place (transparent proxy) will require an allocation when the
address becomes dynamic. A few dereferences of the family were adjusted
to preliminary check for the address pointer to exist at all. The
remaining operations were already performed under control of a
successful retrieval.

MINOR: peers: use conn->dst for the peer's target address

The target address is duplicated from the peer's configured one. For
now we keep the target address as-is but we'll have to dynamically
allocate it and place it into the stream instead. Maybe a sockaddr_dup()
will help by the way.

The "show peers" part is safe as it's already called after checking
the addresses' validity.

MINOR: lua: switch to conn->dst for a connection's target address

This one will soon need a dynamic allocation, though this will be
temporary as ideally the address will be placed on the stream and no
connection will be allocated anymore.

MINOR: ssl-sock: use conn->dst instead of &conn->addr.to

This part can be definitive as the check was already in place.

MINOR: connection: use conn->{src,dst} instead of &conn->addr.{from,to}

This is in preparation for the switch to dynamic address allocation,
let's migrate the code using the old fields to the pointers instead.
Note that no extra check was added for now, the purpose is only to
get the code to use the pointers and still work.

In the proxy protocol message handling we make sure the addresses are
properly allocated before declaring them unset.

MINOR: connection: add new src and dst fields

At the moment we're facing difficulties with connection reuse based on
the fact that connections may be allocated very early only to set a
target address in transparent mode. With the imminent removal of the
legacy mode, the connection reuse by a same stream will not exist
anymore and all this awful complexity is not justified anymore. However
we still need to be able to assign addresses somewhere.

Thus instead of allocating a connection, we'll only place addresses where
needed in the stream during operations. But this takes quite some room
(typically 128 bytes). This is a nice opportunity for cleaning all this
up and dynamically allocatating the addresses fields, which will result
in actually saving memory from connection structs since most of the time
the client's "to" address is not used and the server's "from" is not used
either, thus saving ~256 bytes per end-to-end connection.

For now these new "src" and "dst" pointers point to addr.from and addr.to.
This will allow us to smoothly update the whole code to use these pointers
prior to going further and switching them to pools.

CLEANUP: connection: remove the now unused conn_get_{from,to}_addr()

These functions are not used anymore. They didn't report failures and
as such were often misused. conn_get_src() and conn_get_dst() now
replaced them everywhere.

MINOR: http: check the source address via conn_get_src() in sample fetch functions

In smp_fetch_url32_src() and smp_fetch_base32_src() it's better to
validate that the source address was properly initialized since it
will soon be dynamic, thus let's call conn_get_src().

MINOR: lua: use conn_get_{src,dst} to retrieve connection addresses

This replaces the previous conn_get_{from,to}_addr() and reuses the
existing error checks.

MINOR: http/htx: use conn_get_dst() to retrieve the destination address

When adding the X-Original-To header, let's use conn_get_dst() and make
sure it succeeds, since  previous call to conn_get_to_addr() was unchecked.

MINOR: log: use conn_get_{dst,src}() to retrieve the cli/frt/bck/srv/ addresses

This also allows us to check that the operation succeeded without
logging whatever remained in the memory area in case of failure.

MINOR: stream/cli: use conn_get_{src,dst} in "show sess" and "show peers" output

The stream outputs requires to retrieve connections sources and
destinations. The previous call involving conn_get_{to,from}_addr()
was missing a status check which has now been integrated with the
new call since these places already handle connection errors there.

The same code parts were reused for "show peers" and were modified
similarly.

MINOR: stream-int: use conn_get_{src,dst} in conn_si_send_proxy()

These ones replace the previous conn_get_{from,to}_addr() used to wait
for the connection establishment before sending a LOCAL line. The
error handling was preserved.

MINOR: tcp: replace various calls to conn_get_{from,to}_addr with conn_get_{src,dst}

These calls include the operation's status. When the check was already
present, it was merged with the call. when it was not present, it was
added.

MINOR: ssl: switch to conn_get_dst() to retrieve the destination address

This replaces conn_get_to_addr() and the subsequent check.

MINOR: backend: switch to conn_get_{src,dst}() for port and address mapping

The backend connect code uses conn_get_{from,to}_addr to forward addresses
in transparent mode and to map server ports, without really checking if the
operation succeeds. In preparation of future changes, let's switch to
conn_get_{src,dst}() and integrate status check for possible failures.

MINOR: frontend: switch to conn_get_{src,dst}() for logging and debugging

The frontend accept code uses conn_get_{from,to}_addr for logging and
debugging, without really checking if the operation succeeds. In
preparation of future changes, let's switch to conn_get_{src,dst}() and
integrate status check for possible failures.

MINOR: connection: add conn_get_src() and conn_get_dst()

These functions currently are the same as conn_get_from_addr() and
conn_get_to_addr() respectively except that they return a status for
the operation that the caller can test.

BUG/MEDIUM: mux-h1: Trim excess server data at the end of a transaction

At the end of a transaction, when the conn_stream is detach from the H1
connection, on the server side, we must release the input buffer to trim any
excess data received from the server to be sure to block invalid responses.  A
typical example of such data would be from a buggy server responding to a HEAD
with some data, or sending more than the advertised content-length.

This issue was reported on Gitbub. See issue #176.

This patch must be backported to 2.0 and 1.9.

MINOR: config: Warn only if the option http-use-htx is used with "no" prefix

No warning message is emitted anymore if the option is used to enable the
HTX. But it is still diplayed when the "no" prefix is used to disable the HTX
explicitly. So, for existing configs, we display a warning only if there is a
change in the behavior of HAProxy between the 2.1 and the previous versions.

BUG/MINOR: checks: do not exit tcp-checks from the middle of the loop

There's a comment above tcpcheck_main() clearly stating that no return
statement should be placed in the middle, still we did have one after
installing the mux. It looks mostly harmless though as it will only
fail to mark the server as being in error in case of allocation failure
or config issue.

This fix should be backported to 2.0 and probably 1.9 as well.

CLEANUP: mux-h2: Remove unused flags H2_SF_CHNK_*

Since the legacy HTTP code was removed, these flags are unused anymore.

BUG/MINOR: session: Send a default HTTP error if accept fails for a H1 socket

If session_accept_fd() fails for a raw HTTP socket, we try to send an HTTP error
500. But we must not rely on error messages of the proxy or on the array
http_err_chunks because these are HTX messages. And it should be too expensive
to convert an HTX message to a raw message at this place. So instead, we send a
default HTTP error message from the array http_err_msgs.

This patch must be backported to 2.0 and 1.9.

BUG/MINOR: session: Emit an HTTP error if accept fails only for H1 connection

If session_accept_fd() fails for a raw HTTP socket, we try to send an HTTP error
500. But, we must also take care it is an HTTP/1 connection. We cannot rely on
the mux at this stage, because the error, if any, happens before or during its
creation. So, instead, we check if the mux_proto is specified or not. Indeed,
the mux h1 cannot be forced on the bind line and there is no ALPN to choose
another mux on a raw socket. So if there is no mux_proto defined for a raw HTTP
socket, we are sure to have an HTTP/1 connection.

This patch must be backported to 2.0 and 1.9.

MINOR: http: Don't store raw HTTP errors in chunks anymore

Default HTTP error messages are stored in an array of chunks. And since the HTX
was added, these messages are also converted in HTX and stored in another
array. But now, the first array is not used anymore because the legacy HTTP mode
was removed.

So now, only the array with the HTX messages are kept. The other one was
removed.

MINOR: global: Preset tune.max_http_hdr to its default value

By default, this tune parameter is set to MAX_HTTP_HDR. This assignment is done
after the configuration parsing, when we check the configuration validity. So
during the configuration parsing, its value is 0. Now, it is set to MAX_HTTP_HDR
from the start. So, it is possible to rely on it during the configuration
parsing.

DOC: config: Remove unsupported req* and rsp* keywords

As a result, the section 6 ( HTTP header manipulation) was removed and replace
by the section 10 (Cache).

MINOR: proxy/http_ana: Remove unused req_exp/rsp_exp and req_add/rsp_add lists

The keywords req* and rsp* are now unsupported. So the corresponding lists are
now unused. It is safe to remove them from the structure proxy.

As a result, the code dealing with these rules in HTTP analyzers was also
removed.

MINOR: proxy: Remove the unused list of block rules

The keyword "block" is now unsupported. So the list of block rules is now
unused. It can be safely removed from the structure proxy.

MEDIUM: config: Remove parsing of req* and rsp* directives

It was announced for the 2.1. Following keywords are now unsupported:

  * reqadd, reqallow, reqiallow, reqdel, reqidel, reqdeny, reqideny, reqpass,
    reqipass, reqrep, reqirep reqtarpit, reqitarpit

  * rspadd, rspdel, rspidel, rspdeny, rspideny, rsprep, rspirep

a fatal error is emitted if one of these keyword is found during the
configuraion parsing.

DOC: config: Update as a result of the legacy HTTP removal

Doc about the options 'http-tunnel' and 'http-use-htx' were removed.

MINOR: proxy: Remove support of the option 'http-tunnel'

The option 'http-tunnel' is deprecated and it was only used in the legacy HTTP
mode. So this option is now totally ignored and a warning is emitted during
HAProxy startup if it is found in a configuration file.

BUG/MINOR: debug: Remove flags CO_FL_SOCK_WR_ENA/CO_FL_SOCK_RD_ENA

These flags were removed by the commit 03abf2d31 ("MEDIUM: connections: Remove
CONN_FL_SOCK*").

This patch may be backported to 2.0.

REORG: proto_htx: Move HTX analyzers & co to http_ana.{c,h} files

The old module proto_http does not exist anymore. All code dedicated to the HTTP
analysis is now grouped in the file proto_htx.c. So, to finish the polishing
after removing the legacy HTTP code, proto_htx.{c,h} files have been moved in
http_ana.{c,h} files.

In addition, all HTX analyzers and related functions prefixed with "htx_" have
been renamed to start with "http_" instead.

CLEANUP: proto_http: Move remaining code from proto_http.c to proto_htx.c

CLEANUP: proto_http: Remove unecessary includes and comments

CLEANUP: channel: Remove the unused flag CF_WAKE_CONNECT

This flag is tested or cleared but never set anymore.

CLEANUP: proto_http: Group remaining flags of the HTTP transaction

MINOR: proto_http: Remove the unused flag HTTP_MSGF_WAIT_CONN

This flag is set but never used. So remove it.

MINOR: proto_http: Remove unused http txn flags

Many flags of the HTTP transction (TX_*) are now unused and useless. So the
flags TX_WAIT_CLEANUP, TX_HDR_CONN_*, TX_CON_CLO_SET and TX_CON_KAL_SET were
removed. Most of TX_CON_WANT_* were also removed. Only TX_CON_WANT_TUN has been
kept.

MINOR: hlua: Remove useless test on TX_CON_WANT_* flags

When an HTTP applet is initialized, it is useless to force server-close mode on
the HTTP transaction because the connection mode is now handled by muxes. In
HTX, during analysis, the flag TX_CON_WANT_CLO is set by default in
htx_wait_for_request(), and TX_CON_WANT_SCL is never tested anywere.

MAJOR: http: Remove the HTTP legacy code

First of all, all legacy HTTP analyzers and all functions exclusively used by
them were removed. So the most of the functions in proto_http.{c,h} were
removed. Only functions to deal with the HTTP transaction have been kept. Then,
http_msg and hdr_idx modules were entirely removed. And finally the structure
http_msg was lightened of all its useless information about the legacy HTTP. The
structure hdr_ctx was also removed because unused now, just like unused states
in the enum h1_state. Note that the memory pool "hdr_idx" was removed and
"http_txn" is now smaller.

MINOR: stream: Remove code relying on the legacy HTTP mode

Dump of streams information was updated to remove useless info. And it is not
necessary anymore to update msg->sov..

MAJOR: filters: Remove code relying on the legacy HTTP mode

This commit breaks the compatibility with filters still relying on the legacy
HTTP code. The legacy callbacks were removed (http_data, http_chunk_trailers and
http_forward_data).

For now, the filters must still set the flag FLT_CFG_FL_HTX to be used on HTX
streams.

MINOR: stats: Remove code relying on the legacy HTTP mode

The part of the applet dealing with raw buffer was removed, for the HTTP part
only. So the old functions stats_send_http_headers() and
stats_send_http_redirect() were removed and replaced by the htx ones. The legacy
applet I/O handler was replaced by the htx one. And the parsing of POST data was
purged of the legacy HTTP code.

MINOR: flt_trace: Remove code relying on the legacy HTTP mode

The legacy HTTP callbacks were removed (trace_http_data,
trace_http_chunk_trailers and trace_http_forward_data). And the loop on the HTTP
headers was updated to only handle HTX messages.

MEDIUM: compression: Remove code relying on the legacy HTTP mode

The legacy HTTP callbacks were removed (comp_http_data, comp_http_chunk_trailers
and comp_http_forward_data). Functions emitting compressed chunks of data for
the legacy HTTP mode were also removed. The state for the compression filter was
updated accordingly. The compression context and the algorigttm used to compress
data are the only useful information remaining.

MEDIUM: cache: Remove code relying on the legacy HTTP mode

The applet delivering cached objects based on the legacy HTTP code was removed
as the filter callback cache_store_http_forward_data(). And the action analyzing
the response coming from the server to store it in the cache or not was purged
of the legacy HTTP code.

MINOR: http_act: Remove code relying on the legacy HTTP mode

Actions updating the request or the response start-line are concerned.

MEDIUM: hlua: Remove code relying on the legacy HTTP mode

HTTP applets are concerned and functions of the HTTP class too.

MEDIUM: backend: Remove code relying on the HTTP legacy mode

The L7 loadbalancing algorithms are concerned (uri, url_param and hdr), the
"sni" parameter on the server line and the "source" parameter on the server line
when used with "use_src hdr_ip()".

MINOR: proxy: Don't adjust connection mode of HTTP proxies anymore

This was only used for the legacy HTTP mode where the connection mode was
handled by the HTTP analyzers. In HTX, the function http_adjust_conn_mode() does
nothing. The connection mode is handled by the muxes.

CLEANUP: proxy: Remove the flag PR_O2_USE_HTX

This flag is now unused. So we can safely remove it.

MINOR: contrib/prometheus-exporter: Remove tests on the option 'http-use-htx'

Configuring the Prometheus service is now always valid for HTTP proxies. So we
don't rely anymore on the flag PR_O2_USE_HTX.

MINOR: cache: Remove tests on the option 'http-use-htx'

All cache filters now store HTX messages. So it is useless to test if a cache is
used at the same time by a legacy HTTP proxy and an HTX one.

MINOR: hlua: Remove tests on the option 'http-use-htx' to reject TCP applets

TCP applets are now forbidden for all HTTP proxies because all of them use the
HTX mode. So we don't rely anymore on the flag PR_O2_USE_HTX to do so.

MINOR: proxy: Remove tests on the option 'http-use-htx' during H1 upgrade

To know if an upgrade from TCP to H1 must be performed, we now only need to know
if a non HTX stream is assigned to an HTTP backend. So we don't rely anymore on
the flag PR_O2_USE_HTX to handle such upgrades.

MINOR: stream: Remove tests on the option 'http-use-htx' in stream_new()

All streams created for an HTTP proxy must now use the HTX internal
resprentation. So, it is no more necessary to test the flag PR_O2_USE_HTX. It
means a stream is an HTX stream if the frontend is an HTTP proxy or if the
frontend multiplexer, if any, set the flag MX_FL_HTX.

MINOR: config: Remove tests on the option 'http-use-htx'

All proxies have now the option PR_O2_USE_HTX set. So it is useless to still
test it when the validity of the configuratio is checked.

MEDIUM: http_fetch: Remove code relying on HTTP legacy mode

Since the legacy HTTP mode is disbabled, all HTTP sample fetches work on HTX
streams. So it is safe to remove all code relying on HTTP legacy mode. Among
other things, the function smp_prefetch_http() was removed with the associated
macros CHECK_HTTP_MESSAGE_FIRST() and CHECK_HTTP_MESSAGE_FIRST_PERM().

MINOR: stream: Rely on HTX analyzers instead of legacy HTTP ones

Since the legacy HTTP mode is disabled, old HTTP analyzers do nothing but call
those of the HTX. So, it is safe to directly call HTX analyzers from
process_stream().

MINOR: connection: Remove the multiplexer protocol PROTO_MODE_HTX

Since the legacy HTTP mode is disabled and no multiplexer relies on it anymore,
there is no reason to have 2 multiplexer protocols for the HTTP. So the protocol
PROTO_MODE_HTX was removed and all HTTP multiplexers use now PROTO_MODE_HTTP.

CLEANUP: h2: Remove functions converting h2 requests to raw HTTP/1.1 ones

Because the h2 multiplexer only uses the HTX mode, following H2 functions were
removed :

  * h2_prepare_h1_reqline
  * h2_make_h1_request()
  * h2_make_h1_trailers()

MEDIUM: mux-h2: Remove support of the legacy HTTP mode

Now the H2 multiplexer only works in HTX. Code relying on the legacy HTTP mode
was removed.

MAJOR: http: Deprecate and ignore the option "http-use-htx"

From this commit, the legacy HTTP mode is now definitely disabled. It is the
first commit of a long series to remove the legacy HTTP code. Now, all HTTP
processing is done using the HTX internal representation. Since the version 2.0,
It is the default mode. So now, it is no more possible to disable the HTX to
fallback on the legacy HTTP mode. If you still use "[no] option http-use-htx", a
warning will be emitted during HAProxy startup. Note the passthough multiplexer
is now only usable for TCP proxies.

DOC: htx: Add internal documentation about the HTX

MINOR: htx: Slightly update htx_dump() to report better messages

Sign of <tail_addr>, <head_addr> and <end_addr> is respsected to not convert -1
into its unsigned representation.

MINOR: htx: Use an array of char to store HTX blocks

Instead of using a array of (struct block), it is more natural and intuitive to
use an array of char. Indeed, not only (struct block) are stored in this array,
but also their payload.

MINOR: htx: Deduce the number of used blocks from tail and head values

<head> and <tail> fields are now signed 32-bits integers. For an empty HTX
message, these fields are set to -1. So the field <used> is now useless and can
safely be removed. To know if an HTX message is empty or not, we just compare
<head> against -1 (it also works with <tail>). The function htx_nbblks() has
been added to get the number of used blocks.

CLEANUP: htx: Remove the unsued function htx_add_blk_type_size()

DOC: htx: Update comments in HTX files

This patch may be backported to 2.0 to have accurate comments.

MINOR: proto_htx: Don't stop forwarding when there is a post-connect processing

The TXN flag HTTP_MSGF_WAIT_CONN is now ignored on HTX streams. There is no
reason to not start to forward data in HTX. This is required for the legacy mode
and this was copied from it during the HTX development. But it is simply
useless.

MINOR: backend/htx: Don't rewind output data to set the sni on a srv connection

Rewind on output data is useless for HTX streams.

MINOR: proto_htx: Add the function htx_return_srv_error()

Instead of using a function from the legacy HTTP, the HTX code now uses its own
one.

MINOR: proto_htx: Rely on the HTX function to apply a redirect rules

There is no reason to use the legacy HTTP version here, which falls back on the
HTX version in this case.

MINOR: proto_htx: Directly call htx_check_response_for_cacheability()

Instead of using the HTTP legacy version.

BUG/MINOR: hlua: Make the function txn:done() HTX aware

The function hlua_txn_done() still relying, for the HTTP, on the legacy HTTP
mode. Now, for HTX streams, it calls the function htx_reply_and_close().

This patch must be backported to 2.0 and 1.9.

BUG/MINOR: cache/htx: Make maxage calculation HTX aware

The function http_calc_maxage() was not updated to be HTX aware. So the header
"Cache-Control" on the response was never parsed to find "max-age" or "s-maxage"
values.

This patch must be backported to 2.0 and 1.9.

BUG/MINOR: http_htx: Initialize HTX error messages for TCP proxies

Since the HTX is the default mode for all proxies, HTTP and TCP, we must
initialize all HTX error messages for all HTX-aware proxies and not only for
HTTP ones. It is required to support HTTP upgrade for TCP proxies.

This patch must be backported to 2.0.

BUG/MINOR: http_fetch: Fix http_auth/http_auth_group when called from TCP rules

These sample fetches rely on the static fnuction get_http_auth(). For HTX
streams and TCP proxies, this last one gets its HTX message from the request's
channel. When called from an HTTP rule, There is no problem. Bu when called from
TCP rules for a TCP proxy, this buffer is a raw buffer not an HTX message. For
instance, using the following TCP rule leads to a crash :

  tcp-request content accept if { http_auth(Users) }

To fix the bug, we must rely on the HTX message returned by the function
smp_prefetch_htx(). So now, the HTX message is passed as argument to the
function get_http_auth().

This patch must be backported to 2.0 and 1.9.

MINOR: mux-h2: Don't adjust anymore the amount of data sent in h2_snd_buf()

Because the infinite forward is HTX aware, it is useless to tinker with the
number of bytes really sent. This was fixed long ago for the H1 and forgotten to
do so for the H2.

BUG/MINOR: backend: do not try to install a mux when the connection failed

If si_connect() failed, do not try to install the mux nor to complete
the operations or add the connection to an idle list, and abort quickly
instead. No obvious side effects were identified, but continuing to
allocate some resources after something has already failed seems risky.

This was a result of a prior fix which already wanted to push this code
further : aa089d80b ("BUG/MEDIUM: server: Defer the mux init until after
xprt has been initialized.") but it ought to have pushed it even further
to maintain the error check just after si_connect().

To be backported to 2.0 and 1.9.