upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-04-15 21:59:41 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
haproxy/src/proto_rhttp.c

507 lines
14 KiB
C
Raw Permalink Normal View History

MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
#include <stdio.h>
#include <string.h>
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
#include <haproxy/api.h>
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
#include <haproxy/connection.h>
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
#include <haproxy/errors.h>
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
#include <haproxy/intops.h>
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
#include <haproxy/list.h>
#include <haproxy/listener.h>
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
#include <haproxy/log.h>
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
#include <haproxy/proto_tcp.h>
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
#include <haproxy/protocol.h>
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
#include <haproxy/proxy.h>
BUG/MINOR: proto_reverse_connect: support SNI on active connect SNI may be specify on a server line for connecting to the remote host. This requires to manually set it on the connection via ssl_sock_set_servername(). This step was missing when a server line was used for active reverse HTTP. Fix this by adding the missing ssl_sock_set_servername() invocation inside new_reverse_conn(). Note that for the moment, no session is instantiated to carry active reverse connection. A direct consequence of this is that SNI sample retrieval may crash depending if it depends on session parameters. This should be fixed by a later commit. In the meantime, this patch is sufficient to support simple SNI value such as constant expressions. No need to backport.
2023-11-03 06:03:49 -04:00
#include <haproxy/sample.h>
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
#include <haproxy/server.h>
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
#include <haproxy/session.h>
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
#include <haproxy/sock.h>
BUG/MINOR: proto_reverse_connect: support SNI on active connect SNI may be specify on a server line for connecting to the remote host. This requires to manually set it on the connection via ssl_sock_set_servername(). This step was missing when a server line was used for active reverse HTTP. Fix this by adding the missing ssl_sock_set_servername() invocation inside new_reverse_conn(). Note that for the moment, no session is instantiated to carry active reverse connection. A direct consequence of this is that SNI sample retrieval may crash depending if it depends on session parameters. This should be fixed by a later commit. In the meantime, this patch is sufficient to support simple SNI value such as constant expressions. No need to backport.
2023-11-03 06:03:49 -04:00
#include <haproxy/ssl_sock.h>
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
#include <haproxy/task.h>
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
MINOR: rhttp: rename proto_reverse_connect This commit is renaming of module proto_reverse_connect to proto_rhttp. This name is selected as it is shorter and more precise.
2023-11-21 04:41:06 -05:00
#include <haproxy/proto_rhttp.h>
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct proto_fam proto_fam_rhttp = {
.name = "rhttp",
MINOR: protocol: properly assign the sock_domain and sock_family When we finally split sock_domain from sock_family in 2.3, something was not cleanly finished. The family is what should be stored in the address while the domain is what is supposed to be passed to socket(). But for the custom addresses, we did the opposite, just because the protocol_lookup() function was acting on the domain, not the family (both of which are equal for non-custom addresses). This is an API bug but there's no point backporting it since it does not have visible effects. It was visible in the code since a few places were using PF_UNIX while others were comparing the domain against AF_MAX instead of comparing the family. This patch clarifies this in the comments on top of proto_fam, addresses the indexing issue and properly reconfigures the two custom families.
2024-08-09 12:59:46 -04:00
.sock_domain = AF_INET,
.sock_family = AF_CUST_RHTTP_SRV,
MINOR: protocol: add the real address family to the protocol For custom families, there's sometimes an underlying real address and it would be nice to be able to directly use the real family in calls to bind() and connect() without having to add explicit checks for exceptions everywhere. Let's add a .real_family field to struct proto_fam for this. For now it's always equal to the family except for non-transferable ones such as rhttp where it's equal to the custom one (anything else could fit).
2024-08-09 14:13:10 -04:00
.real_family = AF_CUST_RHTTP_SRV,
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
.bind = rhttp_bind_receiver,
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
};
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct protocol proto_rhttp = {
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
.name = "rev",
MINOR: rhttp: remove the unused outgoing connect() function A dummy connect() function previously had to be installed for the log server so that a reverse-http address could be referenced on a "server" line, but after the recent rework of the server line parsing, this is no longer needed, and this is actually annoying as it makes one believe there is a way to connect outside, which is not true. Let's now get rid of this function.
2023-11-17 04:52:13 -05:00
/* connection layer (no outgoing connection) */
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
.listen = rhttp_bind_listener,
.enable = rhttp_enable_listener,
.disable = rhttp_disable_listener,
BUG/MINOR: rhttp: prevent listener suspend Ensure "disable frontend" on a reverse HTTP listener is forbidden by returing -1 on suspend callback. Suspending such a listener has unknown effect and so is not properly implemented for now. This should be backported up to 2.9.
2024-05-16 11:35:31 -04:00
.suspend = rhttp_suspend_listener,
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
.add = default_add_listener,
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
.unbind = rhttp_unbind_receiver,
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
.resume = default_resume_listener,
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
.accept_conn = rhttp_accept_conn,
CLEANUP: proto: rename TID affinity callbacks Since the following patch, protocol API to update a connection TID affinity has been extended. commit 1a43b9f32c71267e3cb514aa70a13c75adb20742 MINOR: proto: extend connection thread rebind API The single callback set_affinity has been splitted in 3 different functions which are called at different stages during listener_accept(), depending on accept queue push success or not. However, the naming was rendered confusing by the usage of function prefix 1 and 2. Rename proto callback related to TID affinity update and use the following names : * bind_tid_prep * bind_tid_commit * bind_tid_reset This commit should probably be backported at least up to 3.0 with the above patch. This is because the fix was recently backported and it would allow to keep changes minimal between the two versions. It could even be backported up to 2.8 if there is no major conflict.
2024-07-11 05:32:29 -04:00
.bind_tid_prep = rhttp_bind_tid_prep,
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
/* address family */
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
.fam = &proto_fam_rhttp,
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
/* socket layer */
.proto_type = PROTO_TYPE_STREAM,
.sock_type = SOCK_STREAM,
.sock_prot = IPPROTO_TCP,
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
.rx_listening = rhttp_accepting_conn,
.receivers = LIST_HEAD_INIT(proto_rhttp.receivers),
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
};
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
static struct connection *new_reverse_conn(struct listener *l, struct server *srv)
{
struct connection *conn = conn_new(srv);
MINOR: proto_reverse_connect: support source address setting Support backend configuration for explicit source address on pre-connect. These settings can be specified via "source" backend keyword or directly on the server line. Previously, all source parameters triggered a BUG_ON() when binding a reverse connect listener. This was done because some settings are incompatible with reverse connect context : this is the case for all source settings which do not specify a fixed address but rather rely on a frontend connection. Indeed, in case of preconnect, connection is initiated on its own without the existence of a previous frontend connection. This patch allows to use a source parameter with a fixed address. All other settings (usesrc client/clientip/hdr_ip) are rejected on listener binding. On connection init, alloc_bind_address() is used to set the optional source address.
2023-10-02 11:17:46 -04:00
struct sockaddr_storage *bind_addr = NULL;
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
struct session *sess = NULL;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
if (!conn)
goto err;
MINOR: rhttp: add count of active conns per thread Add a new member <nb_rhttp_conns> in thread_ctx structure. Its purpose is to count the current number of opened reverse HTTP connections regarding from their listeners membership. This patch will be useful to support multi-thread for active reverse HTTP, in order to select the less loaded thread. Note that despite access to <nb_rhttp_conns> are only done by the current thread, atomic operations are used. This is because once multi-thread support will be added, external threads will also retrieve values from others.
2023-11-22 11:55:58 -05:00
HA_ATOMIC_INC(&th_ctx->nb_rhttp_conns);
BUG/MINOR: rhttp: initialize session origin after preconnect reversal Since the following commit, session is initialized early for rhttp preconnect. 12c40c25a9520fe3365950184fe724a1f4e91d03 MEDIUM: rhttp: create session for active preconnect Session origin member was not set. However, this prevents several session fetches to not work as expected. Worst, this caused a regression as previously session was created after reversal with origin member defined. This was reported by user William Manley on the mailing-list which rely on set-dst. One possible fix would be to set origin on session_new(). However, as this is done before reversal, some session members may be incorrectly initialized, in particular source and destination address. Thus, session origin is only set after reversal is completed. This ensures that session fetches have the same behavior on standard connections and reversable ones. This does not need to be backported.
2024-05-23 09:06:52 -04:00
/* session origin is only set after reversal. This ensures fetches
* will be functional only after reversal, in particular src/dst.
*/
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
sess = session_new(l->bind_conf->frontend, l, NULL);
if (!sess)
goto err;
conn_set_owner(conn, sess, conn_session_free);
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
conn_set_reverse(conn, &l->obj_type);
MINOR: proto_reverse_connect: support source address setting Support backend configuration for explicit source address on pre-connect. These settings can be specified via "source" backend keyword or directly on the server line. Previously, all source parameters triggered a BUG_ON() when binding a reverse connect listener. This was done because some settings are incompatible with reverse connect context : this is the case for all source settings which do not specify a fixed address but rather rely on a frontend connection. Indeed, in case of preconnect, connection is initiated on its own without the existence of a previous frontend connection. This patch allows to use a source parameter with a fixed address. All other settings (usesrc client/clientip/hdr_ip) are rejected on listener binding. On connection init, alloc_bind_address() is used to set the optional source address.
2023-10-02 11:17:46 -04:00
if (alloc_bind_address(&bind_addr, srv, srv->proxy, NULL) != SRV_STATUS_OK)
goto err;
conn->src = bind_addr;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
sockaddr_alloc(&conn->dst, 0, 0);
if (!conn->dst)
goto err;
*conn->dst = srv->addr;
BUG/MINOR: proto_reverse_connect: fix preconnect with startup name resolution addr member of server structure is not set consistently depending on the server address type. When using <IP:PORT> notation, its port is properly set. However, when using <HOSTNAME:PORT>, only IP address is set after startup name resolution but its port is left to 0. This behavior causes preconnect to not be functional when using server with hostname for startup name resolution. Indeed, only srv.addr is used as connect argument through function new_reverse_conn(). To fix this, rely on srv.svc_port : this member is always set for servers using IP or hostname. This is similar to connect_server() on the backend side. This does not need to be backported.
2023-09-21 09:44:17 -04:00
set_host_port(conn->dst, srv->svc_port);
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
MINOR: rhttp: support PROXY emission on preconnect Extend preconnect to support PROXY protocol emission. Code is duplicated from connect_server() into new_reverse_conn(). This is necessary to support send-proxy on server line used as rhttp.
2024-05-14 10:34:49 -04:00
conn->send_proxy_ofs = 0;
BUG/MINOR: server: check for either proxy-protocol v1 or v2 to send hedaer As reported in issue #2882, using "no-send-proxy-v2" on a server line does not properly disable the use of proxy-protocol if it was enabled in a default-server directive in combination with other PP options. The reason for this is that the sending of a proxy header is determined by a test on srv->pp_opts without any distinction, so disabling PPv2 while leaving other options results in a PPv1 header to be sent. Let's fix this by explicitly testing for the presence of either send-proxy or send-proxy-v2 when deciding to send a proxy header. This can be backported to all versions. Thanks to Andre Sencioles (@asenci) for reporting the issue and testing the fix.
2025-03-02 21:58:46 -05:00
if (srv->pp_opts & SRV_PP_ENABLED) {
MINOR: rhttp: support PROXY emission on preconnect Extend preconnect to support PROXY protocol emission. Code is duplicated from connect_server() into new_reverse_conn(). This is necessary to support send-proxy on server line used as rhttp.
2024-05-14 10:34:49 -04:00
conn->flags |= CO_FL_SEND_PROXY;
conn->send_proxy_ofs = 1; /* must compute size */
}
/* TODO support SOCKS4 */
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
if (conn_prepare(conn, protocol_lookup(conn->dst->ss_family, PROTO_TYPE_STREAM, 0), srv->xprt))
goto err;
if (conn->ctrl->connect(conn, 0) != SF_ERR_NONE)
goto err;
BUG/MINOR: proto_reverse_connect: support SNI on active connect SNI may be specify on a server line for connecting to the remote host. This requires to manually set it on the connection via ssl_sock_set_servername(). This step was missing when a server line was used for active reverse HTTP. Fix this by adding the missing ssl_sock_set_servername() invocation inside new_reverse_conn(). Note that for the moment, no session is instantiated to carry active reverse connection. A direct consequence of this is that SNI sample retrieval may crash depending if it depends on session parameters. This should be fixed by a later commit. In the meantime, this patch is sufficient to support simple SNI value such as constant expressions. No need to backport.
2023-11-03 06:03:49 -04:00
#ifdef USE_OPENSSL
OPTIM: proto_rhttp: Don't set SNI for non-ssl connections There is no reason to set the SNI for non-ssl connections. It is not really an issue because ssl_sock_set_servername() function will do nothing. But there is no reason to uselessly evaluate an expression. No backport needed, because there is no bug.
2025-09-03 10:47:00 -04:00
if (conn_is_ssl(conn) && srv->ssl_ctx.sni) {
BUG/MINOR: proto_reverse_connect: support SNI on active connect SNI may be specify on a server line for connecting to the remote host. This requires to manually set it on the connection via ssl_sock_set_servername(). This step was missing when a server line was used for active reverse HTTP. Fix this by adding the missing ssl_sock_set_servername() invocation inside new_reverse_conn(). Note that for the moment, no session is instantiated to carry active reverse connection. A direct consequence of this is that SNI sample retrieval may crash depending if it depends on session parameters. This should be fixed by a later commit. In the meantime, this patch is sufficient to support simple SNI value such as constant expressions. No need to backport.
2023-11-03 06:03:49 -04:00
struct sample *sni_smp = NULL;
/* TODO remove NULL session which can cause crash depending on the SNI sample expr used. */
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
sni_smp = sample_fetch_as_type(srv->proxy, sess, NULL,
BUG/MINOR: proto_reverse_connect: support SNI on active connect SNI may be specify on a server line for connecting to the remote host. This requires to manually set it on the connection via ssl_sock_set_servername(). This step was missing when a server line was used for active reverse HTTP. Fix this by adding the missing ssl_sock_set_servername() invocation inside new_reverse_conn(). Note that for the moment, no session is instantiated to carry active reverse connection. A direct consequence of this is that SNI sample retrieval may crash depending if it depends on session parameters. This should be fixed by a later commit. In the meantime, this patch is sufficient to support simple SNI value such as constant expressions. No need to backport.
2023-11-03 06:03:49 -04:00
SMP_OPT_DIR_REQ | SMP_OPT_FINAL,
srv->ssl_ctx.sni, SMP_T_STR);
if (smp_make_safe(sni_smp))
ssl_sock_set_servername(conn, sni_smp->data.u.str.area);
}
#endif /* USE_OPENSSL */
MINOR: rhttp: support PROXY emission on preconnect Extend preconnect to support PROXY protocol emission. Code is duplicated from connect_server() into new_reverse_conn(). This is necessary to support send-proxy on server line used as rhttp.
2024-05-14 10:34:49 -04:00
/* The CO_FL_SEND_PROXY flag may have been set by the connect method,
* if so, add our handshake pseudo-XPRT now.
*/
if (conn->flags & CO_FL_HANDSHAKE) {
if (xprt_add_hs(conn) < 0)
goto err;
}
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
if (conn_xprt_start(conn) < 0)
goto err;
if (!srv->use_ssl ||
(!srv->ssl_ctx.alpn_str && !srv->ssl_ctx.npn_str) ||
srv->mux_proto) {
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
if (conn_install_mux_be(conn, NULL, sess, NULL) < 0)
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
goto err;
}
return conn;
err:
MINOR: rhttp: add log on connection allocation failure Add an error log when new_reverse_conn() fails. This may help to diagnose future issues on reverse HTTP.
2024-05-21 10:35:11 -04:00
if (l->rx.rhttp.state != LI_PRECONN_ST_ERR) {
send_log(l->bind_conf->frontend, LOG_ERR,
"preconnect %s::%s: Error on conn allocation.\n",
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname);
l->rx.rhttp.state = LI_PRECONN_ST_ERR;
}
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
/* No need to free session as conn.destroy_cb will take care of it. */
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
if (conn) {
BUG/MINOR: proto_reverse_connect: fix FD leak on connection error Listener using "rev@" address is responsible to setup connection and reverse it using a server instance. If an error occured before reversal is completed, proper freeing must be taken care of by the listener as no session exists for this. Currently, there is two locations where a connection is freed on error before reversal inside reverse_connect protocol. Both of these were incomplete as several function must be used to ensure connection is properly freed. This commit fixes this by reusing the same cleaning mechanism used inside H2 multiplexer. One of the biggest drawback before this patch was that connection FD was not properly removed from fdtab which caused a file-descriptor leak. No need to backport this.
2023-09-29 10:04:21 -04:00
conn_stop_tracking(conn);
conn_xprt_shutw(conn);
conn_xprt_close(conn);
conn_sock_shutw(conn, 0);
conn_ctrl_close(conn);
if (conn->destroy_cb)
conn->destroy_cb(conn);
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
/* Mark connection as non-reversable. This prevents conn_free()
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
* to reschedule rhttp task on freeing a preconnect connection.
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
*/
conn->reverse.target = NULL;
conn_free(conn);
}
return NULL;
}
MINOR: proto_reverse_connect: refactor preconnect failure When a connection is freed during preconnect before reversal, the error must be notified to the listener to remove any connection reference and rearm a new preconnect attempt. Currently, this can occur through 2 code paths : * conn_free() called directly by H2 mux * error during conn_create_mux(). For this case, connection is flagged with CO_FL_ERROR and reverse_connect task is woken up. The process task handler is then responsible to call conn_free() for such connection. Duplicated steps where done both in conn_free() and process task handler. These are now removed. To facilitate code maintenance, dedicated operation have been centralized in a new function rev_notify_preconn_err() which is called by conn_free().
2023-09-22 10:28:35 -04:00
/* Report that a connection used for preconnect on listener <l> is freed before
* reversal is completed. This is used to cleanup any reference to the
* connection and rearm a new preconnect attempt.
*/
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
void rhttp_notify_preconn_err(struct listener *l)
MINOR: proto_reverse_connect: refactor preconnect failure When a connection is freed during preconnect before reversal, the error must be notified to the listener to remove any connection reference and rearm a new preconnect attempt. Currently, this can occur through 2 code paths : * conn_free() called directly by H2 mux * error during conn_create_mux(). For this case, connection is flagged with CO_FL_ERROR and reverse_connect task is woken up. The process task handler is then responsible to call conn_free() for such connection. Duplicated steps where done both in conn_free() and process task handler. These are now removed. To facilitate code maintenance, dedicated operation have been centralized in a new function rev_notify_preconn_err() which is called by conn_free().
2023-09-22 10:28:35 -04:00
{
/* Receiver must reference a reverse connection as pending. */
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
BUG_ON(!l->rx.rhttp.pend_conn);
MINOR: proto_reverse_connect: refactor preconnect failure When a connection is freed during preconnect before reversal, the error must be notified to the listener to remove any connection reference and rearm a new preconnect attempt. Currently, this can occur through 2 code paths : * conn_free() called directly by H2 mux * error during conn_create_mux(). For this case, connection is flagged with CO_FL_ERROR and reverse_connect task is woken up. The process task handler is then responsible to call conn_free() for such connection. Duplicated steps where done both in conn_free() and process task handler. These are now removed. To facilitate code maintenance, dedicated operation have been centralized in a new function rev_notify_preconn_err() which is called by conn_free().
2023-09-22 10:28:35 -04:00
/* Remove reference to the freed connection. */
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.pend_conn = NULL;
MINOR: proto_reverse_connect: refactor preconnect failure When a connection is freed during preconnect before reversal, the error must be notified to the listener to remove any connection reference and rearm a new preconnect attempt. Currently, this can occur through 2 code paths : * conn_free() called directly by H2 mux * error during conn_create_mux(). For this case, connection is flagged with CO_FL_ERROR and reverse_connect task is woken up. The process task handler is then responsible to call conn_free() for such connection. Duplicated steps where done both in conn_free() and process task handler. These are now removed. To facilitate code maintenance, dedicated operation have been centralized in a new function rev_notify_preconn_err() which is called by conn_free().
2023-09-22 10:28:35 -04:00
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
if (l->rx.rhttp.state != LI_PRECONN_ST_ERR) {
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
send_log(l->bind_conf->frontend, LOG_ERR,
"preconnect %s::%s: Error encountered.\n",
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname);
l->rx.rhttp.state = LI_PRECONN_ST_ERR;
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
}
MINOR: proto_reverse_connect: refactor preconnect failure When a connection is freed during preconnect before reversal, the error must be notified to the listener to remove any connection reference and rearm a new preconnect attempt. Currently, this can occur through 2 code paths : * conn_free() called directly by H2 mux * error during conn_create_mux(). For this case, connection is flagged with CO_FL_ERROR and reverse_connect task is woken up. The process task handler is then responsible to call conn_free() for such connection. Duplicated steps where done both in conn_free() and process task handler. These are now removed. To facilitate code maintenance, dedicated operation have been centralized in a new function rev_notify_preconn_err() which is called by conn_free().
2023-09-22 10:28:35 -04:00
/* Rearm a new preconnect attempt. */
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.task->expire = MS_TO_TICKS(now_ms + 1000);
task_queue(l->rx.rhttp.task);
MINOR: proto_reverse_connect: refactor preconnect failure When a connection is freed during preconnect before reversal, the error must be notified to the listener to remove any connection reference and rearm a new preconnect attempt. Currently, this can occur through 2 code paths : * conn_free() called directly by H2 mux * error during conn_create_mux(). For this case, connection is flagged with CO_FL_ERROR and reverse_connect task is woken up. The process task handler is then responsible to call conn_free() for such connection. Duplicated steps where done both in conn_free() and process task handler. These are now removed. To facilitate code maintenance, dedicated operation have been centralized in a new function rev_notify_preconn_err() which is called by conn_free().
2023-09-22 10:28:35 -04:00
}
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
/* Lookup over listener <l> threads for their current count of active reverse
* HTTP connections. Returns the less loaded thread ID.
*/
static unsigned int select_thread(struct listener *l)
{
unsigned long mask = l->rx.bind_thread & _HA_ATOMIC_LOAD(&tg->threads_enabled);
unsigned int load_min = HA_ATOMIC_LOAD(&th_ctx->nb_rhttp_conns);
unsigned int load_thr;
unsigned int ret = tid;
int i;
/* Returns current tid if listener runs on one thread only. */
if (!atleast2(mask))
goto end;
/* Loop over all threads and return the less loaded one. This needs to
* be just an approximation so it's not important if the selected
* thread load has varied since its selection.
*/
for (i = tg->base; mask; mask >>= 1, i++) {
if (!(mask & 0x1))
continue;
load_thr = HA_ATOMIC_LOAD(&ha_thread_ctx[i].nb_rhttp_conns);
if (load_min > load_thr) {
ret = i;
load_min = load_thr;
}
}
end:
return ret;
}
/* Detach <task> from its thread and assign it to <new_tid> thread. The task is
* queued to be woken up on the new thread.
*/
static void task_migrate(struct task *task, uint new_tid)
{
task_unlink_wq(task);
task->expire = TICK_ETERNITY;
task_set_thread(task, new_tid);
task_wakeup(task, TASK_WOKEN_MSG);
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct task *rhttp_process(struct task *task, void *ctx, unsigned int state)
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
{
struct listener *l = ctx;
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct connection *conn = l->rx.rhttp.pend_conn;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
if (conn) {
MINOR: proto_reverse_connect: use connect timeout Use backend connect timeout when a new connection is instantiated for rhttp. This ensures that if connect operation fails after a certain delay, reverse_connect listener task is woken up. This allows to free the current connection and retry a new connect. As a consequence of this change, rev_process() may be woken up even if connection is not reported with CO_FL_ERROR. This happens if timeout fired before any network reported issue. Connection freeing is adjusted as in this case MUX instance is already allocated. Use destroy callback to release MUX context prior to the connection itself. This patch is really useful as a side measure for a haproxy bug impacting connect with SSL for both backend connections and active reverse connect. This is caused by the delayed allocation of MUX allocation. Asynchronous connect error detected at the socket layer is not notified to upper layers. Currently, only connect timeout allows to release this failed connection.
2023-11-07 11:10:38 -05:00
/* Either connection is on error ot the connect timeout fired. */
if (conn->flags & CO_FL_ERROR || tick_is_expired(task->expire, now_ms)) {
/* If mux already instantiated, let it release the
* connection along with its context. Else do cleanup
* directly.
*/
if (conn->mux && conn->mux->destroy) {
conn->mux->destroy(conn->ctx);
}
else {
conn_stop_tracking(conn);
conn_xprt_shutw(conn);
conn_xprt_close(conn);
conn_sock_shutw(conn, 0);
conn_ctrl_close(conn);
if (conn->destroy_cb)
conn->destroy_cb(conn);
conn_free(conn);
}
MINOR: proto_reverse_connect: handle early error before reversal An error can occured on a reverse connection before accept is completed. In this case, no parent session can be notified. Instead, wake up the receiver task on conn_create_mux(). As a counterpart to this, receiver task is extended to match CO_FL_ERROR flag on pending connection. In this case, the onnection is freed. The task is then requeued with a 1 second delay to start a new reverse connection attempt.
2023-08-14 04:52:50 -04:00
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
/* conn_free() must report preconnect failure using rhttp_notify_preconn_err(). */
BUG_ON(l->rx.rhttp.pend_conn);
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
l->rx.rhttp.task->expire = TICKS_TO_MS(now_ms);
MINOR: proto_reverse_connect: handle early error before reversal An error can occured on a reverse connection before accept is completed. In this case, no parent session can be notified. Instead, wake up the receiver task on conn_create_mux(). As a counterpart to this, receiver task is extended to match CO_FL_ERROR flag on pending connection. In this case, the onnection is freed. The task is then requeued with a 1 second delay to start a new reverse connection attempt.
2023-08-14 04:52:50 -04:00
}
else {
CLEANUP: assorted typo fixes in the code and comments This is 37th iteration of typo fixes
2023-11-21 13:54:16 -05:00
/* Spurious receiver task woken up despite pend_conn not ready/on error. */
MINOR: connection: update rhttp flags usage Change the flags used for reversed connection : * CO_FL_REVERSED is now put after reversal for passive connect. For active connect, it is delayed when accept is completed after reversal. * CO_FL_ACT_REVERSING replace the old CO_FL_REVERSED. It is put only for active connect on reversal and removes once accept is done. This allows to identify a connection as reversed during its whole lifetime. This should be useful to extend reverse connect.
2023-11-16 11:13:28 -05:00
BUG_ON(!(conn->flags & CO_FL_ACT_REVERSING));
MINOR: proto_reverse_connect: handle early error before reversal An error can occured on a reverse connection before accept is completed. In this case, no parent session can be notified. Instead, wake up the receiver task on conn_create_mux(). As a counterpart to this, receiver task is extended to match CO_FL_ERROR flag on pending connection. In this case, the onnection is freed. The task is then requeued with a 1 second delay to start a new reverse connection attempt.
2023-08-14 04:52:50 -04:00
/* A connection is ready to be accepted. */
listener_accept(l);
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.task->expire = TICK_ETERNITY;
MINOR: proto_reverse_connect: handle early error before reversal An error can occured on a reverse connection before accept is completed. In this case, no parent session can be notified. Instead, wake up the receiver task on conn_create_mux(). As a counterpart to this, receiver task is extended to match CO_FL_ERROR flag on pending connection. In this case, the onnection is freed. The task is then requeued with a 1 second delay to start a new reverse connection attempt.
2023-08-14 04:52:50 -04:00
}
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
}
else {
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct server *srv = l->rx.rhttp.srv;
MINOR: proto_reverse_connect: use connect timeout Use backend connect timeout when a new connection is instantiated for rhttp. This ensures that if connect operation fails after a certain delay, reverse_connect listener task is woken up. This allows to free the current connection and retry a new connect. As a consequence of this change, rev_process() may be woken up even if connection is not reported with CO_FL_ERROR. This happens if timeout fired before any network reported issue. Connection freeing is adjusted as in this case MUX instance is already allocated. Use destroy callback to release MUX context prior to the connection itself. This patch is really useful as a side measure for a haproxy bug impacting connect with SSL for both backend connections and active reverse connect. This is caused by the delayed allocation of MUX allocation. Asynchronous connect error detected at the socket layer is not notified to upper layers. Currently, only connect timeout allows to release this failed connection.
2023-11-07 11:10:38 -05:00
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
if ((state & TASK_WOKEN_ANY) != TASK_WOKEN_MSG) {
unsigned int new_tid = select_thread(l);
if (new_tid != tid) {
task_migrate(l->rx.rhttp.task, new_tid);
return task;
}
}
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
/* No pending reverse connection, prepare a new one. Store it in the
* listener and return NULL. Connection will be returned later after
* reversal is completed.
*/
MINOR: proto_reverse_connect: use connect timeout Use backend connect timeout when a new connection is instantiated for rhttp. This ensures that if connect operation fails after a certain delay, reverse_connect listener task is woken up. This allows to free the current connection and retry a new connect. As a consequence of this change, rev_process() may be woken up even if connection is not reported with CO_FL_ERROR. This happens if timeout fired before any network reported issue. Connection freeing is adjusted as in this case MUX instance is already allocated. Use destroy callback to release MUX context prior to the connection itself. This patch is really useful as a side measure for a haproxy bug impacting connect with SSL for both backend connections and active reverse connect. This is caused by the delayed allocation of MUX allocation. Asynchronous connect error detected at the socket layer is not notified to upper layers. Currently, only connect timeout allows to release this failed connection.
2023-11-07 11:10:38 -05:00
conn = new_reverse_conn(l, srv);
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.pend_conn = conn;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
/* On success task will be woken up by H2 mux after reversal. */
BUG/MINOR: rhttp: fix reconnect if timeout connect unset Active connect on reverse http relies on connect timeout to detect connection failure. Thus, if this timeout was unset, connection failure may not be properly detected. Fix this by fallback on hardcoded value of 1s for connect if timeout is unset in the configuration. This is considered as a minor bug, as haproxy advises against running with timeout unset. This must be backported up to 2.9.
2025-04-10 12:05:55 -04:00
l->rx.rhttp.task->expire = conn && tick_isset(srv->proxy->timeout.connect) ?
MINOR: proto_reverse_connect: use connect timeout Use backend connect timeout when a new connection is instantiated for rhttp. This ensures that if connect operation fails after a certain delay, reverse_connect listener task is woken up. This allows to free the current connection and retry a new connect. As a consequence of this change, rev_process() may be woken up even if connection is not reported with CO_FL_ERROR. This happens if timeout fired before any network reported issue. Connection freeing is adjusted as in this case MUX instance is already allocated. Use destroy callback to release MUX context prior to the connection itself. This patch is really useful as a side measure for a haproxy bug impacting connect with SSL for both backend connections and active reverse connect. This is caused by the delayed allocation of MUX allocation. Asynchronous connect error detected at the socket layer is not notified to upper layers. Currently, only connect timeout allows to release this failed connection.
2023-11-07 11:10:38 -05:00
tick_add_ifset(now_ms, srv->proxy->timeout.connect) :
MS_TO_TICKS(now_ms + 1000);
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
}
return task;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
int rhttp_bind_receiver(struct receiver *rx, char **errmsg)
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
{
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
rx->flags |= RX_F_BOUND;
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
return ERR_NONE;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
int rhttp_bind_listener(struct listener *listener, char *errmsg, int errlen)
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
{
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
struct task *task;
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
struct proxy *be;
struct server *srv;
struct ist be_name, sv_name;
char *name = NULL;
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
unsigned long mask;
uint task_tid;
if (listener->state != LI_ASSIGNED)
return ERR_NONE; /* already bound */
/* Retrieve the first thread usable for this listener. */
mask = listener->rx.bind_thread & _HA_ATOMIC_LOAD(&tg->threads_enabled);
BUG/MEDIUM: rhttp: fix preconnect on single-thread On initialization of a rhttp bind, the first thread available on the listener is selected to execute the first occurence of the preconnect task. This thread selection was incorrect as it used my_ffsl() which returns value indexed from 1, contrary to tid which are indexed from 0. This cause the first listener thread to be skipped in favor of the second one. Worst, if haproxy runs in single-thread mode, calculated thread ID will be invalid and the task will never run, which prevent any preconnect execution. Fix this by substracting the result of my_ffsl() by 1 to have a value indexed from 0. This must be backported up to 2.9.
2024-05-21 10:35:28 -04:00
task_tid = my_ffsl(mask) - 1 + ha_tgroup_info[listener->rx.bind_tgroup].base;
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
if (!(task = task_new_on(task_tid))) {
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
snprintf(errmsg, errlen, "Out of memory.");
goto err;
}
MEDIUM: rhttp: create session for active preconnect Modify rhttp preconnect by instantiating a new session for each connection attempt. Connection is thus linked to a session directly on its instantiation contrary to previously where no session existed until listener_accept(). This patch will allow to extend rhttp usage. Most notably, it will be useful to use various sample fetches on the server line and extend logging capabilities. Changes are minimal, yet consequences are considered not trivial as for the first time a FE connection session is instantiated before listener_accept(). This requires an extra explicit check in session_accept_fd() to not overwrite an existing session. Also, flag SESS_FL_RELEASE_LI is not set immediately as listener counters must note be decremented if connection and its session are freed before reversal is completed, or else listener counters will be invalid. conn_session_free() is used as connection destroy callback to ensure the session will be freed automatically on connection release.
2023-11-03 11:21:12 -04:00
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
task->process = rhttp_process;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
task->context = listener;
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
listener->rx.rhttp.task = task;
listener->rx.rhttp.state = LI_PRECONN_ST_STOP;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
MINOR: listener: add nbconn kw for reverse connect Previously, maxconn keyword was reused for a specific usage on reverse HTTP binds to specify the number of active connect to proceed. To avoid confusion, introduce a new dedicated keyword 'nbconn' which is specific to reverse HTTP bind. This new keyword is forbidden for non-reverse listener. A fatal error is emitted during config parsing if this rule is not respected. It's safe because it's also forbidden to mix standard and reverse addresses on the same bind line. Internally, nbconn value will be reassigned to 'maxconn' member of bind_conf structure. This ensures that listener layer will automatically reenable the preconnect task each time a connection is closed.
2023-10-19 03:25:20 -04:00
/* Set maxconn which is defined via the special kw nbconn for reverse
* connect. Use a default value of 1 if not set. This guarantees that
CLEANUP: assorted typo fixes in the code and comments This is 37th iteration of typo fixes
2023-11-21 13:54:16 -05:00
* listener will be automatically re-enable each time it fell back below
MINOR: listener: add nbconn kw for reverse connect Previously, maxconn keyword was reused for a specific usage on reverse HTTP binds to specify the number of active connect to proceed. To avoid confusion, introduce a new dedicated keyword 'nbconn' which is specific to reverse HTTP bind. This new keyword is forbidden for non-reverse listener. A fatal error is emitted during config parsing if this rule is not respected. It's safe because it's also forbidden to mix standard and reverse addresses on the same bind line. Internally, nbconn value will be reassigned to 'maxconn' member of bind_conf structure. This ensures that listener layer will automatically reenable the preconnect task each time a connection is closed.
2023-10-19 03:25:20 -04:00
* it due to a connection error.
BUG/MINOR: proto_reverse_connect: set default maxconn If maxconn is not set for preconnect, it assumes we want to establish a single connection. However, this does not work properly in case the connection is closed after reversal. Listener is not resumed by protocol layer to attempt a new preconnect. To fix this, explicitely set maxconn to 1 in the listener instance if none is defined. This ensures the behavior is consistent. A BUG_ON() has been added to validate we never try to use a listener with a 0 maxconn.
2023-09-22 09:51:23 -04:00
*/
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
listener->bind_conf->maxconn = listener->bind_conf->rhttp_nbconn;
BUG/MINOR: proto_reverse_connect: set default maxconn If maxconn is not set for preconnect, it assumes we want to establish a single connection. However, this does not work properly in case the connection is closed after reversal. Listener is not resumed by protocol layer to attempt a new preconnect. To fix this, explicitely set maxconn to 1 in the listener instance if none is defined. This ensures the behavior is consistent. A BUG_ON() has been added to validate we never try to use a listener with a 0 maxconn.
2023-09-22 09:51:23 -04:00
if (!listener->bind_conf->maxconn)
listener->bind_conf->maxconn = 1;
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
name = strdup(listener->bind_conf->rhttp_srvname);
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
if (!name) {
snprintf(errmsg, errlen, "Out of memory.");
goto err;
}
sv_name = ist(name);
be_name = istsplit(&sv_name, '/');
if (!istlen(sv_name)) {
snprintf(errmsg, errlen, "Invalid server name: '%s'.", name);
goto err;
}
if (!(be = proxy_be_by_name(ist0(be_name)))) {
snprintf(errmsg, errlen, "No such backend: '%s'.", name);
goto err;
}
CLEANUP: server: rename server_find_by_name() to server_find() This function doesn't just look at the name but also the ID when the argument starts with a '#'. So the name is not correct and explains why this function is not always used when the name only is needed, and why the list-based findserver() is used instead. So let's just call the function "server_find()", and rename its generation-id based cousin "server_find_unique()".
2025-07-10 04:59:06 -04:00
if (!(srv = server_find(be, ist0(sv_name)))) {
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
snprintf(errmsg, errlen, "No such server: '%s/%s'.", ist0(be_name), ist0(sv_name));
goto err;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
if (srv->flags & SRV_F_RHTTP) {
snprintf(errmsg, errlen, "Cannot use reverse HTTP server '%s/%s' as target to a reverse bind.", ist0(be_name), ist0(sv_name));
MINOR: proto_reverse_connect: prevent transparent server for pre-connect Prevent using transparent servers for pre-connect on startup by emitting a fatal error. This is used to ensure we never try to connect to a target with an unspecified destination address or port.
2023-09-21 10:54:41 -04:00
goto err;
}
if (srv_is_transparent(srv)) {
snprintf(errmsg, errlen, "Cannot use transparent server '%s/%s' as target to a reverse bind.", ist0(be_name), ist0(sv_name));
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
goto err;
}
/* Check that server uses HTTP/2 either with proto or ALPN. */
if ((!srv->mux_proto || !isteqi(srv->mux_proto->token, ist("h2"))) &&
(!srv->use_ssl || !isteqi(ist(srv->ssl_ctx.alpn_str), ist("\x02h2")))) {
snprintf(errmsg, errlen, "Cannot reverse connect with server '%s/%s' unless HTTP/2 is activated on it with either proto or alpn keyword.", name, ist0(sv_name));
goto err;
}
MINOR: proto_reverse_connect: support source address setting Support backend configuration for explicit source address on pre-connect. These settings can be specified via "source" backend keyword or directly on the server line. Previously, all source parameters triggered a BUG_ON() when binding a reverse connect listener. This was done because some settings are incompatible with reverse connect context : this is the case for all source settings which do not specify a fixed address but rather rely on a frontend connection. Indeed, in case of preconnect, connection is initiated on its own without the existence of a previous frontend connection. This patch allows to use a source parameter with a fixed address. All other settings (usesrc client/clientip/hdr_ip) are rejected on listener binding. On connection init, alloc_bind_address() is used to set the optional source address.
2023-10-02 11:17:46 -04:00
/* Prevent dynamic source address settings. */
if (((srv->conn_src.opts & CO_SRC_TPROXY_MASK) &&
(srv->conn_src.opts & CO_SRC_TPROXY_MASK) != CO_SRC_TPROXY_ADDR) ||
((srv->proxy->conn_src.opts & CO_SRC_TPROXY_MASK) &&
(srv->proxy->conn_src.opts & CO_SRC_TPROXY_MASK) != CO_SRC_TPROXY_ADDR)) {
snprintf(errmsg, errlen, "Cannot reverse connect with server '%s/%s' which uses dynamic source address setting.", name, ist0(sv_name));
goto err;
}
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
ha_free(&name);
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
listener->rx.rhttp.srv = srv;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
listener_set_state(listener, LI_LISTEN);
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
return ERR_NONE;
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
err:
ha_free(&name);
return ERR_ALERT | ERR_FATAL;
}
BUG/MINOR: rhttp: prevent listener suspend Ensure "disable frontend" on a reverse HTTP listener is forbidden by returing -1 on suspend callback. Suspending such a listener has unknown effect and so is not properly implemented for now. This should be backported up to 2.9.
2024-05-16 11:35:31 -04:00
/* Do not support "disable frontend" for rhttp protocol. */
int rhttp_suspend_listener(struct listener *l)
{
send_log(l->bind_conf->frontend, LOG_ERR, "cannot disable a reverse-HTTP listener.\n");
return -1;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
void rhttp_enable_listener(struct listener *l)
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
{
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
if (l->rx.rhttp.state < LI_PRECONN_ST_INIT) {
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
send_log(l->bind_conf->frontend, LOG_INFO,
"preconnect %s::%s: Initiating.\n",
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname);
l->rx.rhttp.state = LI_PRECONN_ST_INIT;
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
}
BUG/MINOR: rhttp: fix task_wakeup state TASK_WOKEN_ANY was incorrectly used as argument to task_wakeup() for rhttp preconnect task. This value is used as a flag. Replace it by proper individual values. This is labelled as a bug but it has no known impact. This should be backported up to 2.9.
2024-05-16 11:37:46 -04:00
task_wakeup(l->rx.rhttp.task, TASK_WOKEN_INIT);
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
void rhttp_disable_listener(struct listener *l)
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
{
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
if (l->rx.rhttp.state < LI_PRECONN_ST_FULL) {
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
send_log(l->bind_conf->frontend, LOG_INFO,
MINOR: listener: add nbconn kw for reverse connect Previously, maxconn keyword was reused for a specific usage on reverse HTTP binds to specify the number of active connect to proceed. To avoid confusion, introduce a new dedicated keyword 'nbconn' which is specific to reverse HTTP bind. This new keyword is forbidden for non-reverse listener. A fatal error is emitted during config parsing if this rule is not respected. It's safe because it's also forbidden to mix standard and reverse addresses on the same bind line. Internally, nbconn value will be reassigned to 'maxconn' member of bind_conf structure. This ensures that listener layer will automatically reenable the preconnect task each time a connection is closed.
2023-10-19 03:25:20 -04:00
"preconnect %s::%s: Running with nbconn %d reached.\n",
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname,
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
l->bind_conf->maxconn);
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.state = LI_PRECONN_ST_FULL;
MINOR: proto_reverse_connect: emit log for preconnect Add reporting using send_log() for preconnect operation. This is minimal to ensure we understand the current status of listener in active reverse connect. To limit logging quantity, only important transition are considered. This requires to implement a minimal state machine as a new field in receiver structure. Here are the logs produced : * Initiating : first time preconnect is enabled on a listener * Error : last preconnect attempt interrupted on a connection error * Reaching maxconn : all necessary connections were reversed and are operational on a listener
2023-09-22 09:55:24 -04:00
}
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct connection *rhttp_accept_conn(struct listener *l, int *status)
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
{
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
struct connection *conn = l->rx.rhttp.pend_conn;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
if (!conn) {
BUG/MINOR: proto_reverse_connect: set default maxconn If maxconn is not set for preconnect, it assumes we want to establish a single connection. However, this does not work properly in case the connection is closed after reversal. Listener is not resumed by protocol layer to attempt a new preconnect. To fix this, explicitely set maxconn to 1 in the listener instance if none is defined. This ensures the behavior is consistent. A BUG_ON() has been added to validate we never try to use a listener with a 0 maxconn.
2023-09-22 09:51:23 -04:00
/* Reverse connect listener must have an explicit maxconn set
CLEANUP: assorted typo fixes in the code and comments This is 37th iteration of typo fixes
2023-11-21 13:54:16 -05:00
* to ensure it is re-enabled on connection error.
BUG/MINOR: proto_reverse_connect: set default maxconn If maxconn is not set for preconnect, it assumes we want to establish a single connection. However, this does not work properly in case the connection is closed after reversal. Listener is not resumed by protocol layer to attempt a new preconnect. To fix this, explicitely set maxconn to 1 in the listener instance if none is defined. This ensures the behavior is consistent. A BUG_ON() has been added to validate we never try to use a listener with a 0 maxconn.
2023-09-22 09:51:23 -04:00
*/
BUG_ON(!l->bind_conf->maxconn);
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
/* Instantiate a new conn if maxconn not yet exceeded. */
BUG/MINOR: proto_reverse_connect: set default maxconn If maxconn is not set for preconnect, it assumes we want to establish a single connection. However, this does not work properly in case the connection is closed after reversal. Listener is not resumed by protocol layer to attempt a new preconnect. To fix this, explicitely set maxconn to 1 in the listener instance if none is defined. This ensures the behavior is consistent. A BUG_ON() has been added to validate we never try to use a listener with a 0 maxconn.
2023-09-22 09:51:23 -04:00
if (l->nbconn <= l->bind_conf->maxconn) {
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
/* Try first if a new thread should be used for the new connection. */
unsigned int new_tid = select_thread(l);
if (new_tid != tid) {
task_migrate(l->rx.rhttp.task, new_tid);
*status = CO_AC_DONE;
return NULL;
}
/* No need to use a new thread, use the opportunity to alloc the connection right now. */
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.pend_conn = new_reverse_conn(l, l->rx.rhttp.srv);
if (!l->rx.rhttp.pend_conn) {
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
*status = CO_AC_PAUSE;
return NULL;
}
}
*status = CO_AC_DONE;
return NULL;
}
/* listener_accept() must not be called if no pending connection is not yet reversed. */
MINOR: connection: update rhttp flags usage Change the flags used for reversed connection : * CO_FL_REVERSED is now put after reversal for passive connect. For active connect, it is delayed when accept is completed after reversal. * CO_FL_ACT_REVERSING replace the old CO_FL_REVERSED. It is put only for active connect on reversal and removes once accept is done. This allows to identify a connection as reversed during its whole lifetime. This should be useful to extend reverse connect.
2023-11-16 11:13:28 -05:00
BUG_ON(!(conn->flags & CO_FL_ACT_REVERSING));
conn->flags &= ~CO_FL_ACT_REVERSING;
conn->flags |= CO_FL_REVERSED;
MINOR: muxes: Rename mux_ctl_type values to use MUX_CTL_ prefix Instead of the generic MUX_, we now use MUX_CTL_ prefix for all mux_ctl_type value. This will avoid any ambiguities with other enums, especially with a new one that will be added to get information on mux streams.
2023-11-28 08:27:51 -05:00
conn->mux->ctl(conn, MUX_CTL_REVERSE_CONN, NULL);
MEDIUM: h2: prevent stream opening before connection reverse completed HTTP/2 demux must be handled with care for active reverse connection. Until accept has been completed, it should be forbidden to handle HEADERS frame as session is not yet ready to handle streams. To implement this, use the flag H2_CF_DEM_TOOMANY which blocks demux process. This flag is automatically set just after conn_reverse() invocation. The flag is removed on rev_accept_conn() callback via a new H2 ctl enum. H2 tasklet is woken up to restart demux process. As a side-effect, reporting in H2 mux may be blocked as demux functions are used to convert error status at the connection level with CO_FL_ERROR. To ensure error is reported for a reverse connection, check h2c_is_dead() specifically for this case in h2_wake(). This change also has its own side-effect : h2c_is_dead() conditions have been adjusted to always exclude !h2c->conn->owner condition which is always true for reverse connection or else H2 mux may kill them unexpectedly.
2023-08-14 10:38:23 -04:00
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
l->rx.rhttp.pend_conn = NULL;
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
*status = CO_AC_NONE;
return conn;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
void rhttp_unbind_receiver(struct listener *l)
MINOR: proto_reverse_connect: parse rev@ addresses for bind Implement parsing for "rev@" addresses on bind line. On config parsing, server name is stored on the bind_conf. Several new callbacks are defined on reverse_connect protocol to complete parsing. listen callback is used to retrieve the server instance from the bind_conf server name. If found, the server instance is stored on the receiver. Checks are implemented to ensure HTTP/2 protocol only is used by the server.
2023-08-07 11:56:36 -04:00
{
l->rx.flags &= ~RX_F_BOUND;
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
}
CLEANUP: proto: rename TID affinity callbacks Since the following patch, protocol API to update a connection TID affinity has been extended. commit 1a43b9f32c71267e3cb514aa70a13c75adb20742 MINOR: proto: extend connection thread rebind API The single callback set_affinity has been splitted in 3 different functions which are called at different stages during listener_accept(), depending on accept queue push success or not. However, the naming was rendered confusing by the usage of function prefix 1 and 2. Rename proto callback related to TID affinity update and use the following names : * bind_tid_prep * bind_tid_commit * bind_tid_reset This commit should probably be backported at least up to 3.0 with the above patch. This is because the fix was recently backported and it would allow to keep changes minimal between the two versions. It could even be backported up to 2.8 if there is no major conflict.
2024-07-11 05:32:29 -04:00
int rhttp_bind_tid_prep(struct connection *conn, int new_tid)
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
{
CLEANUP: assorted typo fixes in the code and comments This is 38th iteration of typo fixes
2023-12-29 14:05:20 -05:00
/* Explicitly disable connection thread migration on accept. Indeed,
MEDIUM: rhttp: support multi-thread active connect Implement support for active HTTP reverse task migration on listener threads. This operation is done each time a new reversable connection will be instantiated. Instead of directly allocate the connection, a lookup is done among all the listener threads. A comparison is done to select the thread with the smallest number of current reverse connection. If the thread found is different from the current one, the connection allocation is delayed and the task rescheduled on the chosen thread. The connection will then be created and pinned on the new thread. This mechanisms allows to balance reverse HTTP connections accross different threads. Note that rhttp_set_affinity is still defined to disable thread migration on accept. This is necessary as it's unsafe to move an existing connection to another thread. However, active reverse task migration should be sufficient to distribute connections accross several threads. Better than that, this design allows to differentiate standard frontend and reversable connections. The latest are designed to be long-lived so it's useful to have their repartition solely based on others reversed connections.
2023-11-22 12:02:37 -05:00
* it's unsafe to move a connection with its FD to another thread. Note
* that active reverse task thread migration should be sufficient to
CLEANUP: assorted typo fixes in the code and comments This is 38th iteration of typo fixes
2023-12-29 14:05:20 -05:00
* ensure repartition of reversed connections across listener threads.
MEDIUM: proto_reverse_connect: bootstrap active reverse connection Implement active reverse connection initialization. This is done through a new task stored in the receiver structure. This task is instantiated via bind callback and first woken up via enable callback. Task handler is separated into two halves. On the first step, a new connection is allocated and stored in <pend_conn> member of the receiver. This new client connection will proceed to connect using the server instance referenced in the bind_conf. When connect has successfully been executed and HTTP/2 connection is ready for exchange after SETTINGS, reverse_connect task is woken up. As <pend_conn> is still set, the second halve is executed which only execute listener_accept(). This will in turn execute accept_conn callback which is defined to return the pending connection. The task is automatically requeued inside accept_conn callback if bind maxconn is not yet reached. This allows to specify how many connection should be opened. Each connection is instantiated and reversed serially one by one until maxconn is reached. conn_free() has been modified to handle failure if a reverse connection fails before being accepted. In this case, no session exists to notify about the failure. Instead, reverse_connect task is requeud with a 1 second delay, giving time to fix a possible network issue. This will allow to attempt a new connection reverse. Note that for the moment connection rebinding after accept is disabled for simplicity. Extra operations are required to migrate an existing connection and its stack to a new thread which will be implemented later.
2023-08-23 11:16:07 -04:00
*/
return -1;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
int rhttp_accepting_conn(const struct receiver *rx)
MINOR: proto: define dedicated protocol for active reverse connect A new protocol named "reverse_connect" is created. This will be used to instantiate connections that are opened by a reverse bind. For the moment, only a minimal set of callbacks are defined with no real work. This will be extended along the next patches.
2023-08-01 11:27:06 -04:00
{
return 1;
}
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
INITCALL1(STG_REGISTER, protocol_register, &proto_rhttp);
MINOR: rhttp: add count of active conns per thread Add a new member <nb_rhttp_conns> in thread_ctx structure. Its purpose is to count the current number of opened reverse HTTP connections regarding from their listeners membership. This patch will be useful to support multi-thread for active reverse HTTP, in order to select the less loaded thread. Note that despite access to <nb_rhttp_conns> are only done by the current thread, atomic operations are used. This is because once multi-thread support will be added, external threads will also retrieve values from others.
2023-11-22 11:55:58 -05:00
CLEANUP: assorted typo fixes in the code and comments This is 38th iteration of typo fixes
2023-12-29 14:05:20 -05:00
/* perform minimal initializations */
MINOR: rhttp: add count of active conns per thread Add a new member <nb_rhttp_conns> in thread_ctx structure. Its purpose is to count the current number of opened reverse HTTP connections regarding from their listeners membership. This patch will be useful to support multi-thread for active reverse HTTP, in order to select the less loaded thread. Note that despite access to <nb_rhttp_conns> are only done by the current thread, atomic operations are used. This is because once multi-thread support will be added, external threads will also retrieve values from others.
2023-11-22 11:55:58 -05:00
static void init_rhttp()
{
int i;
for (i = 0; i < MAX_THREADS; i++)
ha_thread_ctx[i].nb_rhttp_conns = 0;
}
INITCALL0(STG_PREPARE, init_rhttp);
Reference in a new issue Copy permalink