upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-03-02 13:20:24 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 23
haproxy/src/session.c

440 lines
14 KiB
C
Raw Normal View History

MINOR: session: start to reintroduce struct session There is now a pointer to the session in the stream, which is NULL for now. The session pool is created as well. Some parts will move from the stream to the session now.
2015-04-03 07:53:24 -04:00
/*
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
* Session management functions.
MINOR: session: start to reintroduce struct session There is now a pointer to the session in the stream, which is NULL for now. The session pool is created as well. Some parts will move from the stream to the session now.
2015-04-03 07:53:24 -04:00
*
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
* Copyright 2000-2015 Willy Tarreau <w@1wt.eu>
MINOR: session: start to reintroduce struct session There is now a pointer to the session in the stream, which is NULL for now. The session pool is created as well. Some parts will move from the stream to the session now.
2015-04-03 07:53:24 -04:00
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
*/
REORG: include: update all files to use haproxy/api.h or api-t.h if needed All files that were including one of the following include files have been updated to only include haproxy/api.h or haproxy/api-t.h once instead: - common/config.h - common/compat.h - common/compiler.h - common/defaults.h - common/initcall.h - common/tools.h The choice is simple: if the file only requires type definitions, it includes api-t.h, otherwise it includes the full api.h. In addition, in these files, explicit includes for inttypes.h and limits.h were dropped since these are now covered by api.h and api-t.h. No other change was performed, given that this patch is large and affects 201 files. At least one (tools.h) was already freestanding and didn't get the new one added.
2020-05-27 06:58:42 -04:00
#include <haproxy/api.h>
REORG: include: move connection.h to haproxy/connection{,-t}.h The type file is becoming a mess, half of it is for the proxy protocol, another good part describes conn_streams and mux ops, it would deserve being split again. At least it was reordered so that elements are easier to find, with the PP-stuff left at the end. The MAX_SEND_FD macro was moved to compat.h as it's said to be the value for Linux.
2020-06-04 12:02:10 -04:00
#include <haproxy/connection.h>
REORG: include: split global.h into haproxy/global{,-t}.h global.h was one of the messiest files, it has accumulated tons of implicit dependencies and declares many globals that make almost all other file include it. It managed to silence a dependency loop between server.h and proxy.h by being well placed to pre-define the required structs, forcing struct proxy and struct server to be forward-declared in a significant number of files. It was split in to, one which is the global struct definition and the few macros and flags, and the rest containing the functions prototypes. The UNIX_MAX_PATH definition was moved to compat.h.
2020-06-04 11:05:57 -04:00
#include <haproxy/global.h>
REORG: include: split common/http.h into haproxy/http{,-t}.h So the enums and structs were placed into http-t.h and the functions into http.h. This revealed that several files were dependeng on http.h but not including it, as it was silently inherited via other files.
2020-06-02 13:11:26 -04:00
#include <haproxy/http.h>
REORG: include: move listener.h to haproxy/listener{,-t}.h stdlib and list were missing from listener.h, otherwise it was OK.
2020-06-04 08:58:24 -04:00
#include <haproxy/listener.h>
REORG: include: move log.h to haproxy/log{,-t}.h The current state of the logging is a real mess. The main problem is that almost all files include log.h just in order to have access to the alert/warning functions like ha_alert() etc, and don't care about logs. But log.h also deals with real logging as well as log-format and depends on stream.h and various other things. As such it forces a few heavy files like stream.h to be loaded early and to hide missing dependencies depending where it's loaded. Among the missing ones is syslog.h which was often automatically included resulting in no less than 3 users missing it. Among 76 users, only 5 could be removed, and probably 70 don't need the full set of dependencies. A good approach would consist in splitting that file in 3 parts: - one for error output ("errors" ?). - one for log_format processing - and one for actual logging.
2020-06-04 16:01:04 -04:00
#include <haproxy/log.h>
REORG: include: move common/memory.h to haproxy/pool.h Now the file is ready to be stored into its final destination. A few minor reorderings were performed to keep the file properly organized, making the various sections more visible (cache & lockless). In addition and to stay consistent, memory.c was renamed to pool.c.
2020-06-02 03:38:52 -04:00
#include <haproxy/pool.h>
REORG: include: move proxy.h to haproxy/proxy{,-t}.h This one is particularly difficult to split because it provides all the functions used to manipulate a proxy state and to retrieve names or IDs for error reporting, and as such, it was included in 73 files (down to 68 after cleanup). It would deserve a small cleanup though the cut points are not obvious at the moment given the number of structs involved in the struct proxy itself.
2020-06-04 16:29:18 -04:00
#include <haproxy/proxy.h>
REORG: include: move session.h to haproxy/session{,-t}.h Almost no change was needed beyond a little bit of reordering of the types file and adjustments to use session-t instead of session at a few places.
2020-06-04 12:58:52 -04:00
#include <haproxy/session.h>
REORG: include: move tcp_rules.h to haproxy/tcp_rules.h There's no type file on this one which is pretty simple.
2020-06-04 11:42:48 -04:00
#include <haproxy/tcp_rules.h>
REORG: include: move vars.h to haproxy/vars{,-t}.h A few includes (sessions.h, stream.h, api-t.h) were added for arguments that were first declared in function prototypes.
2020-06-04 10:25:31 -04:00
#include <haproxy/vars.h>
MINOR: session: start to reintroduce struct session There is now a pointer to the session in the stream, which is NULL for now. The session pool is created as well. Some parts will move from the stream to the session now.
2015-04-03 07:53:24 -04:00
MEDIUM: session: update the session's stick counters upon session_free() Whenever session_free() is called, any possible stick counter stored in the session will be synchronized.
2015-04-04 10:31:16 -04:00
MEDIUM: init: use initcall for all fixed size pool creations This commit replaces the explicit pool creation that are made in constructors with a pool registration. Not only this simplifies the pools declaration (it can be done on a single line after the head is declared), but it also removes references to pools from within constructors. The only remaining create_pool() calls are those performed in init functions after the config is parsed, so there is no more user of potentially uninitialized pool now. It has been the opportunity to remove no less than 12 constructors and 6 init functions.
2018-11-26 05:58:30 -05:00
DECLARE_POOL(pool_head_session, "session", sizeof(struct session));
BUG/MAJOR: sessions: Use an unlimited number of servers for the conn list. When a session adds a connection to its connection list, we used to remove connections for an another server if there were not enough room for our server. This can't work, because those lists are now the list of connections we're responsible for, not just the idle connections. To fix this, allow for an unlimited number of servers, instead of using an array, we're now using a linked list.
2018-12-27 11:20:54 -05:00
DECLARE_POOL(pool_head_sess_srv_list, "session server list",
sizeof(struct sess_srv_list));
MINOR: session: start to reintroduce struct session There is now a pointer to the session in the stream, which is NULL for now. The session pool is created as well. Some parts will move from the stream to the session now.
2015-04-03 07:53:24 -04:00
MEDIUM: connections: Get ride of the xprt_done callback. The xprt_done_cb callback was used to defer some connection initialization until we're connected and the handshake are done. As it mostly consists of creating the mux, instead of using the callback, introduce a conn_create_mux() function, that will just call conn_complete_session() for frontend, and create the mux for backend. In h2_wake(), make sure we call the wake method of the stream_interface, as we no longer wakeup the stream task.
2020-01-22 12:08:48 -05:00
int conn_complete_session(struct connection *conn);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
MINOR: session: introduce session_new() This one creates a new session and does the minimum initialization.
2015-04-04 18:38:48 -04:00
/* Create a a new session and assign it to frontend <fe>, listener <li>,
* origin <origin>, set the current date and clear the stick counters pointers.
* Returns the session upon success or NULL. The session may be released using
MEDIUM: session: count the frontend's connections at a single place There are several places where we see feconn++, feconn--, totalconn++ and an increment on the frontend's number of connections and connection rate. This is done exactly once per session in each direction, so better take care of this counter in the session and simplify the callers. At least it ensures a better symmetry. It also ensures consistency as till now the lua/spoe/peers frontend didn't have these counters properly set, which can be useful at least for troubleshooting.
2017-09-15 04:25:14 -04:00
* session_free(). Note: <li> may be NULL.
MINOR: session: introduce session_new() This one creates a new session and does the minimum initialization.
2015-04-04 18:38:48 -04:00
*/
struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin)
{
struct session *sess;
CLEANUP: pools: rename all pool functions and pointers to remove this "2" During the migration to the second version of the pools, the new functions and pool pointers were all called "pool_something2()" and "pool2_something". Now there's no more pool v1 code and it's a real pain to still have to deal with this. Let's clean this up now by removing the "2" everywhere, and by renaming the pool heads "pool_head_something".
2017-11-24 11:34:44 -05:00
sess = pool_alloc(pool_head_session);
MINOR: session: introduce session_new() This one creates a new session and does the minimum initialization.
2015-04-04 18:38:48 -04:00
if (sess) {
sess->listener = li;
sess->fe = fe;
sess->origin = origin;
sess->accept_date = date; /* user-visible date for logging */
sess->tv_accept = now; /* corrected date for internal use */
memset(sess->stkctr, 0, sizeof(sess->stkctr));
MEDIUM: vars: move the session variables to the session, not the stream It's important that the session-wide variables are in the session and not in the stream.
2015-06-19 05:59:02 -04:00
vars_init(&sess->vars, SCOPE_SESS);
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
sess->task = NULL;
BUG/MEDIUM: session: fix reporting of handshake processing time in the logs The handshake processing time used to be stored per stream, which was valid when there was exactly one stream per session. With H2 and multiplexing it's not the case anymore and the reported handshake times are wrong in the logs as it's computed between the TCP accept() and the stream creation. Let's first move the handshake where it belongs, which is the session. However, this is not enough because we don't want to report an excessive idle time either for H2 (since many requests use the connection). So the solution used here is to have the stream retrieve sess->tv_accept and the handshake duration when the stream is created, and let the mux immediately reset them. This way, the handshake time becomes zero for the second and subsequent requests in H2 (which was already the case in H1), and the idle time exactly counts how long the connection remained unused while it could be used, so in H1 it runs from the end of the previous response and in H2 it runs from the end of the previous request since the channel is already available. This patch will need to be backported to 1.8.
2018-09-05 05:56:48 -04:00
sess->t_handshake = -1; /* handshake not done yet */
MINOR: session: Add the idle duration field into the session The idle duration between two streams is added to the session structure. It is not necessarily pertinent on all protocols. In fact, it is only defined for H1 connections. It is the duration between two H1 transactions. But the .get_cs_info() callback function on the multiplexers only exists because this duration is missing at the session level. So it is a simplification opportunity for a really low cost. To reduce the cost, a hole in the session structure is filled by moving .srv_list field at the end of the structure.
2020-09-30 04:28:02 -04:00
sess->t_idle = -1;
CLEANUP: atomic/tree-wide: replace single increments/decrements with inc/dec This patch replaces roughly all occurrences of an HA_ATOMIC_ADD(&foo, 1) or HA_ATOMIC_SUB(&foo, 1) with the equivalent HA_ATOMIC_INC(&foo) and HA_ATOMIC_DEC(&foo) respectively. These are 507 changes over 45 files.
2021-04-06 07:53:36 -04:00
_HA_ATOMIC_INC(&totalconn);
_HA_ATOMIC_INC(&jobs);
BUG/MAJOR: sessions: Use an unlimited number of servers for the conn list. When a session adds a connection to its connection list, we used to remove connections for an another server if there were not enough room for our server. This can't work, because those lists are now the list of connections we're responsible for, not just the idle connections. To fix this, allow for an unlimited number of servers, instead of using an array, we're now using a linked list.
2018-12-27 11:20:54 -05:00
LIST_INIT(&sess->srv_list);
MEDIUM: sessions: Keep track of which connections are idle. Instead of keeping track of the number of connections we're responsible for, keep track of the number of connections we're responsible for that we are currently considering idling (ie that we are not using, they may be in use by other sessions), that way we can actually reuse connections when we have more connections than the max configured.
2018-12-28 12:50:57 -05:00
sess->idle_conns = 0;
MEDIUM: sessions: Introduce session flags. Add session flags, and add a new flag, SESS_FL_PREFER_LAST, to be set when we use NTLM authentication, and we should reuse the last connection. This should fix using NTLM with HTX. This totally replaces TX_PREFER_LAST. This should be backported to 1.9.
2019-05-29 09:01:50 -04:00
sess->flags = SESS_FL_NONE;
MINOR: session: introduce session_new() This one creates a new session and does the minimum initialization.
2015-04-04 18:38:48 -04:00
}
return sess;
}
MINOR: session: implement session_free() and use it everywhere We want to call this one everywhere we have to kill a session so that future parts we move to the session can be released from there.
2015-04-04 09:54:03 -04:00
void session_free(struct session *sess)
{
MAJOR: sessions: Store multiple outgoing connections in the session. Instead of just storing the last connection in the session, store all of the connections, for at most MAX_SRV_LIST (currently 5) targets. That way we can do keepalive on more than 1 outgoing connection when the client uses HTTP/2.
2018-11-30 11:24:55 -05:00
struct connection *conn, *conn_back;
BUG/MAJOR: sessions: Use an unlimited number of servers for the conn list. When a session adds a connection to its connection list, we used to remove connections for an another server if there were not enough room for our server. This can't work, because those lists are now the list of connections we're responsible for, not just the idle connections. To fix this, allow for an unlimited number of servers, instead of using an array, we're now using a linked list.
2018-12-27 11:20:54 -05:00
struct sess_srv_list *srv_list, *srv_list_back;
MAJOR: connections: Detach connections from streams. Do not destroy the connection when we're about to destroy a stream. This prevents us from doing keepalive on server connections when the client is using HTTP/2, as a new stream is created for each request. Instead, the session is now responsible for destroying connections. When reusing connections, the attach() mux method is now used to create a new conn_stream.
2018-11-13 10:48:36 -05:00
MINOR: session: release the listener with the session, not the stream Since multiple streams can share one session attached to one listener, the listener_release() call must be done in session_free() and not in stream_free(), otherwise we end up with a negative count in H2.
2017-10-18 09:01:14 -04:00
if (sess->listener)
listener_release(sess->listener);
MEDIUM: session: update the session's stick counters upon session_free() Whenever session_free() is called, any possible stick counter stored in the session will be synchronized.
2015-04-04 10:31:16 -04:00
session_store_counters(sess);
MEDIUM: vars: move the session variables to the session, not the stream It's important that the session-wide variables are in the session and not in the stream.
2015-06-19 05:59:02 -04:00
vars_prune_per_sess(&sess->vars);
MAJOR: connections: Detach connections from streams. Do not destroy the connection when we're about to destroy a stream. This prevents us from doing keepalive on server connections when the client is using HTTP/2, as a new stream is created for each request. Instead, the session is now responsible for destroying connections. When reusing connections, the attach() mux method is now used to create a new conn_stream.
2018-11-13 10:48:36 -05:00
conn = objt_conn(sess->origin);
if (conn != NULL && conn->mux)
MINOR: muxes: Pass the context of the mux to destroy() instead of the connection It is mandatory to handle mux upgrades, because during a mux upgrade, the connection will be reassigned to another multiplexer. So when the old one is destroyed, it does not own the connection anymore. Or in other words, conn->ctx does not point to the old mux's context when its destroy() callback is called. So we now rely on the multiplexer context do destroy it instead of the connection. In addition, h1_release() and h2_release() have also been updated in the same way.
2019-04-08 05:23:22 -04:00
conn->mux->destroy(conn->ctx);
BUG/MAJOR: sessions: Use an unlimited number of servers for the conn list. When a session adds a connection to its connection list, we used to remove connections for an another server if there were not enough room for our server. This can't work, because those lists are now the list of connections we're responsible for, not just the idle connections. To fix this, allow for an unlimited number of servers, instead of using an array, we're now using a linked list.
2018-12-27 11:20:54 -05:00
list_for_each_entry_safe(srv_list, srv_list_back, &sess->srv_list, srv_list) {
list_for_each_entry_safe(conn, conn_back, &srv_list->conn_list, session_list) {
CLEANUP: session: slightly simplify idle connection cleanup logic Since previous commit a132e5efa9 ("BUG/MEDIUM: Make sure we leave the session list in session_free().") it's pointless to delete the conn element inside "if" blocks given that the second test is always true as well. Let's simplify this with a single LIST_DEL_INIT() before the test.
2019-11-15 01:04:24 -05:00
LIST_DEL_INIT(&conn->session_list);
MAJOR: sessions: Store multiple outgoing connections in the session. Instead of just storing the last connection in the session, store all of the connections, for at most MAX_SRV_LIST (currently 5) targets. That way we can do keepalive on more than 1 outgoing connection when the client uses HTTP/2.
2018-11-30 11:24:55 -05:00
if (conn->mux) {
conn->owner = NULL;
BUG/MEDIUM: connections: Don't forget to remove CO_FL_SESS_IDLE. If we're adding a connection to the server orphan idle list, don't forget to remove the CO_FL_SESS_IDLE flag, or we will assume later it's still attached to a session. This should be backported to 1.9.
2019-01-31 13:31:19 -05:00
conn->flags &= ~CO_FL_SESS_IDLE;
MEDIUM: sessions: Don't be responsible for connections anymore. Make it so sessions are not responsible for connection anymore, except for connections that are private, and thus can't be shared, otherwise, as soon as a request is done, the session will just add the connection to the orphan connections pool. This will break http-reuse safe, but it is expected to be fixed later.
2020-01-20 07:56:01 -05:00
conn->mux->destroy(conn->ctx);
MAJOR: sessions: Store multiple outgoing connections in the session. Instead of just storing the last connection in the session, store all of the connections, for at most MAX_SRV_LIST (currently 5) targets. That way we can do keepalive on more than 1 outgoing connection when the client uses HTTP/2.
2018-11-30 11:24:55 -05:00
} else {
/* We have a connection, but not yet an associated mux.
* So destroy it now.
*/
conn_stop_tracking(conn);
conn_full_close(conn);
conn_free(conn);
}
}
BUG/MAJOR: sessions: Use an unlimited number of servers for the conn list. When a session adds a connection to its connection list, we used to remove connections for an another server if there were not enough room for our server. This can't work, because those lists are now the list of connections we're responsible for, not just the idle connections. To fix this, allow for an unlimited number of servers, instead of using an array, we're now using a linked list.
2018-12-27 11:20:54 -05:00
pool_free(pool_head_sess_srv_list, srv_list);
MAJOR: connections: Defer mux creation for outgoing connection if alpn is set. If an ALPN (or a NPN) was chosen for a server, defer choosing the mux until after the SSL handshake is done, and the ALPN/NPN has been negociated, so that we know which mux to pick.
2018-11-20 18:16:29 -05:00
}
CLEANUP: pools: rename all pool functions and pointers to remove this "2" During the migration to the second version of the pools, the new functions and pool pointers were all called "pool_something2()" and "pool2_something". Now there's no more pool v1 code and it's a real pain to still have to deal with this. Let's clean this up now by removing the "2" everywhere, and by renaming the pool heads "pool_head_something".
2017-11-24 11:34:44 -05:00
pool_free(pool_head_session, sess);
CLEANUP: atomic/tree-wide: replace single increments/decrements with inc/dec This patch replaces roughly all occurrences of an HA_ATOMIC_ADD(&foo, 1) or HA_ATOMIC_SUB(&foo, 1) with the equivalent HA_ATOMIC_INC(&foo) and HA_ATOMIC_DEC(&foo) respectively. These are 507 changes over 45 files.
2021-04-06 07:53:36 -04:00
_HA_ATOMIC_DEC(&jobs);
MINOR: session: implement session_free() and use it everywhere We want to call this one everywhere we have to kill a session so that future parts we move to the session can be released from there.
2015-04-04 09:54:03 -04:00
}
MEDIUM: session: make use of the connection's destroy callback Now we don't remove the session when a stream dies, instead we detach the stream and let the mux decide to release the connection and call session_free() instead.
2017-10-08 05:26:30 -04:00
/* callback used from the connection/mux layer to notify that a connection is
CLEANUP: Fix a typo in the session subsystem Fixes a typo in the code comments of the session subsystem.
2018-11-25 14:22:10 -05:00
* going to be released.
MEDIUM: session: make use of the connection's destroy callback Now we don't remove the session when a stream dies, instead we detach the stream and let the mux decide to release the connection and call session_free() instead.
2017-10-08 05:26:30 -04:00
*/
void conn_session_free(struct connection *conn)
{
session_free(conn->owner);
BUG/MAJOR: connection: reset conn->owner when detaching from session list Baptiste reported a new crash affecting 2.3 which can be triggered when using H2 on the backend, with http-reuse always and with a tens of clients doing close only. There are a few combined cases which cause this to happen, but each time the issue is the same, an already freed session is dereferenced in session_unown_conn(). Two cases were identified to cause this: - a connection referencing a session as its owner, which is detached from the session's list and is destroyed after this session ends. The test on conn->owner before calling session_unown_conn() is not sufficent as the pointer is not null but is not valid anymore. - a connection that never goes idle and that gets killed form the mux, where session_free() is called first, then conn_free() calls session_unown_conn() which scans the just freed session for older connections. This one is only triggered with DEBUG_UAF The reason for this session to be present here is that it's needed during the connection setup, to be passed to conn_install_mux_be() to mux->init() as the owning session, but it's never deleted aftrewards. Furthermore, even conn_session_free() doesn't delete this pointer after freeing the session that lies there. Both do definitely result in a use-after-free that's more easily triggered under DEBUG_UAF. This patch makes sure that the owner is always deleted after detaching or killing the session. However it is currently not possible to clear the owner right after a synchronous init because the proxy protocol apparently needs it (a reg test checks this), and if we leave it past the connection setup with the session not attached anywhere, it's hard to catch the right moment to detach it. This means that the session may remain in conn->owner as long as the connection has never been added to nor removed from the session's idle list. Given that this patch needs to remain simple enough to be backported, instead it adds a workaround in session_unown_conn() to detect that the element is already not attached anywhere. This fix absolutely requires previous patch "CLEANUP: connection: do not use conn->owner when the session is known" otherwise the situation will be even worse, as some places used to rely on conn->owner instead of the session. The fix could theorically be backported as far as 1.8. However, the code in this area has significantly changed along versions and there are more risks of breaking working stuff than fixing real issues there. The issue was really woken up in two steps during 2.3-dev when slightly reworking the idle conns with commit 08016ab82 ("MEDIUM: connection: Add private connections synchronously in session server list") and when adding support for storing used H2 connections in the session and adding the necessary call to session_unown_conn() in the muxes. But the same test managed to crash 2.2 when built in DEBUG_UAF and patched like this, proving that we used to already leave dangling pointers behind us: | diff --git a/include/haproxy/connection.h b/include/haproxy/connection.h | index f8f235c1a..dd30b5f80 100644 | --- a/include/haproxy/connection.h | +++ b/include/haproxy/connection.h | @@ -458,6 +458,10 @@ static inline void conn_free(struct connection *conn) | sess->idle_conns--; | session_unown_conn(sess, conn); | } | + else { | + struct session *sess = conn->owner; | + BUG_ON(sess && sess->origin != &conn->obj_type); | + } | | sockaddr_free(&conn->src); | sockaddr_free(&conn->dst); It's uncertain whether an existing code path there can lead to dereferencing conn->owner when it's bad, though certain suspicious memory corruption bugs make one think it's a likely candidate. The patch should not be hard to adapt there. Backports to 2.1 and older are left to the appreciation of the person doing the backport. A reproducer consists in this: global nbthread 1 listen l bind :9000 mode http http-reuse always server s 127.0.0.1:8999 proto h2 frontend f bind :8999 proto h2 mode http http-request return status 200 Then this will make it crash within 2-3 seconds: $ h1load -e -r 1 -c 10 http://0:9000/ If it does not, it might be that DEBUG_UAF was not used (it's harder then) and it might be useful to restart.
2020-11-20 11:22:44 -05:00
conn->owner = NULL;
MEDIUM: session: make use of the connection's destroy callback Now we don't remove the session when a stream dies, instead we detach the stream and let the mux decide to release the connection and call session_free() instead.
2017-10-08 05:26:30 -04:00
}
MINOR: session: maintain the session count stats in the session, not the stream This has nothing to do in the stream, as we'll face absurdities when chaining multiple streams. The session is where it must be accounted for.
2015-04-08 12:10:49 -04:00
/* count a new session to keep frontend, listener and track stats up to date */
static void session_count_new(struct session *sess)
{
struct stkctr *stkctr;
void *ptr;
int i;
proxy_inc_fe_sess_ctr(sess->listener, sess->fe);
for (i = 0; i < MAX_SESS_STKCTR; i++) {
stkctr = &sess->stkctr[i];
if (!stkctr_entry(stkctr))
continue;
ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
if (ptr)
CLEANUP: atomic/tree-wide: replace single increments/decrements with inc/dec This patch replaces roughly all occurrences of an HA_ATOMIC_ADD(&foo, 1) or HA_ATOMIC_SUB(&foo, 1) with the equivalent HA_ATOMIC_INC(&foo) and HA_ATOMIC_DEC(&foo) respectively. These are 507 changes over 45 files.
2021-04-06 07:53:36 -04:00
HA_ATOMIC_INC(&stktable_data_cast(ptr, sess_cnt));
MINOR: session: maintain the session count stats in the session, not the stream This has nothing to do in the stream, as we'll face absurdities when chaining multiple streams. The session is where it must be accounted for.
2015-04-08 12:10:49 -04:00
ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
if (ptr)
update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
}
}
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
/* This function is called from the protocol layer accept() in order to
MINOR: Some spelling cleanup in the comments. Signed-off-by: Dave Chiluk <chiluk+haproxy@indeed.com>
2018-06-21 12:03:20 -04:00
* instantiate a new session on behalf of a given listener and frontend. It
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
* returns a positive value upon success, 0 if the connection can be ignored,
MEDIUM: listener: allocate the connection before queuing a new connection Till now we would keep a per-thread queue of pending incoming connections for which we would store: - the listener - the accepted FD - the source address - the source address' length And these elements were first used in session_accept_fd() running on the target thread to allocate a connection and duplicate them again. Doing this induces various problems. The first one is that session_accept_fd() may only run on file descriptors and cannot be reused for QUIC. The second issue is that it induces lots of memory copies and that the listerner queue thrashes a lot of cache, consuming 64 bytes per entry. This patch changes this by allocating the connection before queueing it, and by only placing the connection's pointer into the queue. Indeed, the first two calls used to initialize the connection already store all the information above, which can be retrieved from the connection pointer alone. So we just have to pop one pointer from the target thread, and pass it to session_accept_fd() which only needs the FD for the final settings. This starts to make the accept path a bit more transport-agnostic, and saves memory and CPU cycles at the same time (1% connection rate increase was noticed with 4 threads). Thanks to dividing the accept-queue entry size from 64 to 8 bytes, its size could be increased from 256 to 1024 connections while still dividing the overall size by two. No single queue full condition was met. One minor drawback is that connection may be allocated from one thread's pool to be used into another one. But this already happens a lot with connection reuse so there is really nothing new here.
2020-10-14 11:37:17 -04:00
* or a negative value upon critical failure. The accepted connection is
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
* closed if we return <= 0. If no handshake is needed, it immediately tries
MEDIUM: listener: allocate the connection before queuing a new connection Till now we would keep a per-thread queue of pending incoming connections for which we would store: - the listener - the accepted FD - the source address - the source address' length And these elements were first used in session_accept_fd() running on the target thread to allocate a connection and duplicate them again. Doing this induces various problems. The first one is that session_accept_fd() may only run on file descriptors and cannot be reused for QUIC. The second issue is that it induces lots of memory copies and that the listerner queue thrashes a lot of cache, consuming 64 bytes per entry. This patch changes this by allocating the connection before queueing it, and by only placing the connection's pointer into the queue. Indeed, the first two calls used to initialize the connection already store all the information above, which can be retrieved from the connection pointer alone. So we just have to pop one pointer from the target thread, and pass it to session_accept_fd() which only needs the FD for the final settings. This starts to make the accept path a bit more transport-agnostic, and saves memory and CPU cycles at the same time (1% connection rate increase was noticed with 4 threads). Thanks to dividing the accept-queue entry size from 64 to 8 bytes, its size could be increased from 256 to 1024 connections while still dividing the overall size by two. No single queue full condition was met. One minor drawback is that connection may be allocated from one thread's pool to be used into another one. But this already happens a lot with connection reuse so there is really nothing new here.
2020-10-14 11:37:17 -04:00
* to instantiate a new stream. The connection must already have been filled
* with the incoming connection handle (a fd), a target (the listener) and a
* source address.
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
*/
MEDIUM: listener: allocate the connection before queuing a new connection Till now we would keep a per-thread queue of pending incoming connections for which we would store: - the listener - the accepted FD - the source address - the source address' length And these elements were first used in session_accept_fd() running on the target thread to allocate a connection and duplicate them again. Doing this induces various problems. The first one is that session_accept_fd() may only run on file descriptors and cannot be reused for QUIC. The second issue is that it induces lots of memory copies and that the listerner queue thrashes a lot of cache, consuming 64 bytes per entry. This patch changes this by allocating the connection before queueing it, and by only placing the connection's pointer into the queue. Indeed, the first two calls used to initialize the connection already store all the information above, which can be retrieved from the connection pointer alone. So we just have to pop one pointer from the target thread, and pass it to session_accept_fd() which only needs the FD for the final settings. This starts to make the accept path a bit more transport-agnostic, and saves memory and CPU cycles at the same time (1% connection rate increase was noticed with 4 threads). Thanks to dividing the accept-queue entry size from 64 to 8 bytes, its size could be increased from 256 to 1024 connections while still dividing the overall size by two. No single queue full condition was met. One minor drawback is that connection may be allocated from one thread's pool to be used into another one. But this already happens a lot with connection reuse so there is really nothing new here.
2020-10-14 11:37:17 -04:00
int session_accept_fd(struct connection *cli_conn)
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
{
MEDIUM: listener: allocate the connection before queuing a new connection Till now we would keep a per-thread queue of pending incoming connections for which we would store: - the listener - the accepted FD - the source address - the source address' length And these elements were first used in session_accept_fd() running on the target thread to allocate a connection and duplicate them again. Doing this induces various problems. The first one is that session_accept_fd() may only run on file descriptors and cannot be reused for QUIC. The second issue is that it induces lots of memory copies and that the listerner queue thrashes a lot of cache, consuming 64 bytes per entry. This patch changes this by allocating the connection before queueing it, and by only placing the connection's pointer into the queue. Indeed, the first two calls used to initialize the connection already store all the information above, which can be retrieved from the connection pointer alone. So we just have to pop one pointer from the target thread, and pass it to session_accept_fd() which only needs the FD for the final settings. This starts to make the accept path a bit more transport-agnostic, and saves memory and CPU cycles at the same time (1% connection rate increase was noticed with 4 threads). Thanks to dividing the accept-queue entry size from 64 to 8 bytes, its size could be increased from 256 to 1024 connections while still dividing the overall size by two. No single queue full condition was met. One minor drawback is that connection may be allocated from one thread's pool to be used into another one. But this already happens a lot with connection reuse so there is really nothing new here.
2020-10-14 11:37:17 -04:00
struct listener *l = __objt_listener(cli_conn->target);
MEDIUM: move listener->frontend to bind_conf->frontend Historically, all listeners have a pointer to the frontend. But since the introduction of SSL, we now have an intermediary layer called bind_conf corresponding to a "bind" line. It makes no sense to have the frontend on each listener given that it's the same for all listeners belonging to a same bind_conf. Also certain parts like SSL can only operate on bind_conf and need the frontend. This patch fixes this by moving the frontend pointer from the listener to the bind_conf. The extra indirection is quite cheap given and the places were this is used are very scarce.
2016-12-21 18:13:31 -05:00
struct proxy *p = l->bind_conf->frontend;
MEDIUM: listener: allocate the connection before queuing a new connection Till now we would keep a per-thread queue of pending incoming connections for which we would store: - the listener - the accepted FD - the source address - the source address' length And these elements were first used in session_accept_fd() running on the target thread to allocate a connection and duplicate them again. Doing this induces various problems. The first one is that session_accept_fd() may only run on file descriptors and cannot be reused for QUIC. The second issue is that it induces lots of memory copies and that the listerner queue thrashes a lot of cache, consuming 64 bytes per entry. This patch changes this by allocating the connection before queueing it, and by only placing the connection's pointer into the queue. Indeed, the first two calls used to initialize the connection already store all the information above, which can be retrieved from the connection pointer alone. So we just have to pop one pointer from the target thread, and pass it to session_accept_fd() which only needs the FD for the final settings. This starts to make the accept path a bit more transport-agnostic, and saves memory and CPU cycles at the same time (1% connection rate increase was noticed with 4 threads). Thanks to dividing the accept-queue entry size from 64 to 8 bytes, its size could be increased from 256 to 1024 connections while still dividing the overall size by two. No single queue full condition was met. One minor drawback is that connection may be allocated from one thread's pool to be used into another one. But this already happens a lot with connection reuse so there is really nothing new here.
2020-10-14 11:37:17 -04:00
int cfd = cli_conn->handle.fd;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
struct session *sess;
int ret;
ret = -1; /* assume unrecoverable error by default */
MINOR: listener: prefer to retrieve the socket's settings via the receiver Some socket settings used to be retrieved via the listener and the bind_conf. Now instead we use the receiver and its settings whenever appropriate. This will simplify the removal of the dependency on the listener.
2020-09-03 01:50:19 -04:00
cli_conn->proxy_netns = l->rx.settings->netns;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
MEDIUM: connections: Introduce a new XPRT method, start(). Introduce a new XPRT method, start(). The init() method will now only initialize whatever is needed for the XPRT to run, but any action the XPRT has to do before being ready, such as handshakes, will be done in the new start() method. That way, we will be sure the full stack of xprt will be initialized before attempting to do anything. The init() call is also moved to conn_prepare(). There's no longer any reason to wait for the ctrl to be ready, any action will be deferred until start(), anyway. This means conn_xprt_init() is no longer needed.
2021-03-05 17:37:48 -05:00
if (conn_prepare(cli_conn, l->rx.proto, l->bind_conf->xprt) < 0)
goto out_free_conn;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
conn_ctrl_init(cli_conn);
/* wait for a PROXY protocol header */
MEDIUM: connections: Introduce a handshake pseudo-XPRT. Add a new XPRT that is used when using non-SSL handshakes, such as proxy protocol or Netscaler, instead of taking care of it in conn_fd_handler(). This XPRT is installed when any of those is used, and it removes itself once the handshake is done. This should allow us to remove the distinction between CO_FL_SOCK* and CO_FL_XPRT*.
2019-05-27 06:09:19 -04:00
if (l->options & LI_O_ACC_PROXY)
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
cli_conn->flags |= CO_FL_ACCEPT_PROXY;
MINOR: listener: add the "accept-netscaler-cip" option to the "bind" keyword When NetScaler application switch is used as L3+ switch, informations regarding the original IP and TCP headers are lost as a new TCP connection is created between the NetScaler and the backend server. NetScaler provides a feature to insert in the TCP data the original data that can then be consumed by the backend server. Specifications and documentations from NetScaler: https://support.citrix.com/article/CTX205670 https://www.citrix.com/blogs/2016/04/25/how-to-enable-client-ip-in-tcpip-option-of-netscaler/ When CIP is enabled on the NetScaler, then a TCP packet is inserted just after the TCP handshake. This is composed as: - CIP magic number : 4 bytes Both sender and receiver have to agree on a magic number so that they both handle the incoming data as a NetScaler Client IP insertion packet. - Header length : 4 bytes Defines the length on the remaining data. - IP header : >= 20 bytes if IPv4, 40 bytes if IPv6 Contains the header of the last IP packet sent by the client during TCP handshake. - TCP header : >= 20 bytes Contains the header of the last TCP packet sent by the client during TCP handshake.
2016-06-04 10:11:10 -04:00
/* wait for a NetScaler client IP insertion protocol header */
MEDIUM: connections: Introduce a handshake pseudo-XPRT. Add a new XPRT that is used when using non-SSL handshakes, such as proxy protocol or Netscaler, instead of taking care of it in conn_fd_handler(). This XPRT is installed when any of those is used, and it removes itself once the handshake is done. This should allow us to remove the distinction between CO_FL_SOCK* and CO_FL_XPRT*.
2019-05-27 06:09:19 -04:00
if (l->options & LI_O_ACC_CIP)
MINOR: listener: add the "accept-netscaler-cip" option to the "bind" keyword When NetScaler application switch is used as L3+ switch, informations regarding the original IP and TCP headers are lost as a new TCP connection is created between the NetScaler and the backend server. NetScaler provides a feature to insert in the TCP data the original data that can then be consumed by the backend server. Specifications and documentations from NetScaler: https://support.citrix.com/article/CTX205670 https://www.citrix.com/blogs/2016/04/25/how-to-enable-client-ip-in-tcpip-option-of-netscaler/ When CIP is enabled on the NetScaler, then a TCP packet is inserted just after the TCP handshake. This is composed as: - CIP magic number : 4 bytes Both sender and receiver have to agree on a magic number so that they both handle the incoming data as a NetScaler Client IP insertion packet. - Header length : 4 bytes Defines the length on the remaining data. - IP header : >= 20 bytes if IPv4, 40 bytes if IPv6 Contains the header of the last IP packet sent by the client during TCP handshake. - TCP header : >= 20 bytes Contains the header of the last TCP packet sent by the client during TCP handshake.
2016-06-04 10:11:10 -04:00
cli_conn->flags |= CO_FL_ACCEPT_CIP;
MEDIUM: connections: Introduce a handshake pseudo-XPRT. Add a new XPRT that is used when using non-SSL handshakes, such as proxy protocol or Netscaler, instead of taking care of it in conn_fd_handler(). This XPRT is installed when any of those is used, and it removes itself once the handshake is done. This should allow us to remove the distinction between CO_FL_SOCK* and CO_FL_XPRT*.
2019-05-27 06:09:19 -04:00
/* Add the handshake pseudo-XPRT */
if (cli_conn->flags & (CO_FL_ACCEPT_PROXY | CO_FL_ACCEPT_CIP)) {
if (xprt_add_hs(cli_conn) != 0)
goto out_free_conn;
}
MINOR: session: make use of session_new() when creating a new session It's better than open-coding it.
2015-04-04 18:39:16 -04:00
sess = session_new(p, l, &cli_conn->obj_type);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
if (!sess)
goto out_free_conn;
MEDIUM: connection: add a destroy callback This callback will be used to release upper layers when a mux is in use. Given that the mux can be asynchronously deleted, we need a way to release the extra information such as the session. This callback will be called directly by the mux upon releasing everything and before the connection itself is released, so that the callee can find its information inside the connection if needed. The way it currently works is not perfect, and most likely this should instead become a mux release callback, but for now we have no easy way to add mux-specific stuff, and since there's one mux per connection, it works fine this way.
2017-10-08 05:16:46 -04:00
conn_set_owner(cli_conn, sess, NULL);
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
/* now evaluate the tcp-request layer4 rules. We only need a session
* and no stream for these rules.
*/
CLEANUP: tcp rules: mention everywhere that tcp-conn rules are L4 This is in order to make integration of tcp-request-session cleaner : - tcp_exec_req_rules() was renamed tcp_exec_l4_rules() - LI_O_TCP_RULES was renamed LI_O_TCP_L4_RULES (LI_O_*'s horrible indent was also fixed and a provision was left for L5 rules).
2016-10-21 10:34:21 -04:00
if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) {
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
/* let's do a no-linger now to close with a single RST. */
setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
ret = 0; /* successful termination */
goto out_free_sess;
}
MEDIUM: connections: Introduce a new XPRT method, start(). Introduce a new XPRT method, start(). The init() method will now only initialize whatever is needed for the XPRT to run, but any action the XPRT has to do before being ready, such as handshakes, will be done in the new start() method. That way, we will be sure the full stack of xprt will be initialized before attempting to do anything. The init() call is also moved to conn_prepare(). There's no longer any reason to wait for the ctrl to be ready, any action will be deferred until start(), anyway. This means conn_xprt_init() is no longer needed.
2021-03-05 17:37:48 -05:00
/* TCP rules may flag the connection as needing proxy protocol, now that it's done we can start ourxprt */
if (conn_xprt_start(cli_conn) < 0)
goto out_free_conn;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
MEDIUM: frontend: move the fd-specific settings to session_accept_fd() The frontend is generic and does not depend on a file descriptor, so applying some socket options to the incoming fd is not its role. Let's move the setsockopt() calls earlier in session_accept_fd() where others are done as well.
2015-04-05 11:56:47 -04:00
/* Adjust some socket options */
REORG: listener: move the listening address to a struct receiver The address will be specific to the receiver so let's move it there.
2020-08-27 01:48:42 -04:00
if (l->rx.addr.ss_family == AF_INET || l->rx.addr.ss_family == AF_INET6) {
MEDIUM: frontend: move the fd-specific settings to session_accept_fd() The frontend is generic and does not depend on a file descriptor, so applying some socket options to the incoming fd is not its role. Let's move the setsockopt() calls earlier in session_accept_fd() where others are done as well.
2015-04-05 11:56:47 -04:00
setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
if (p->options & PR_O_TCP_CLI_KA) {
MEDIUM: frontend: move the fd-specific settings to session_accept_fd() The frontend is generic and does not depend on a file descriptor, so applying some socket options to the incoming fd is not its role. Let's move the setsockopt() calls earlier in session_accept_fd() where others are done as well.
2015-04-05 11:56:47 -04:00
setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
BUILD: tcp: condition TCP keepalive settings to platforms providing them Previous commit b24bc0d ("MINOR: tcp: Support TCP keepalive parameters customization") broke non-Linux builds as TCP_KEEP{CNT,IDLE,INTVL} are not necessarily defined elsewhere. This patch adds the required #ifdefs to condition the visibility of the keywords, and adds a mention in the doc about their dependency on Linux.
2020-07-08 23:58:51 -04:00
#ifdef TCP_KEEPCNT
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
if (p->clitcpka_cnt)
setsockopt(cfd, IPPROTO_TCP, TCP_KEEPCNT, &p->clitcpka_cnt, sizeof(p->clitcpka_cnt));
BUILD: tcp: condition TCP keepalive settings to platforms providing them Previous commit b24bc0d ("MINOR: tcp: Support TCP keepalive parameters customization") broke non-Linux builds as TCP_KEEP{CNT,IDLE,INTVL} are not necessarily defined elsewhere. This patch adds the required #ifdefs to condition the visibility of the keywords, and adds a mention in the doc about their dependency on Linux.
2020-07-08 23:58:51 -04:00
#endif
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
BUILD: tcp: condition TCP keepalive settings to platforms providing them Previous commit b24bc0d ("MINOR: tcp: Support TCP keepalive parameters customization") broke non-Linux builds as TCP_KEEP{CNT,IDLE,INTVL} are not necessarily defined elsewhere. This patch adds the required #ifdefs to condition the visibility of the keywords, and adds a mention in the doc about their dependency on Linux.
2020-07-08 23:58:51 -04:00
#ifdef TCP_KEEPIDLE
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
if (p->clitcpka_idle)
setsockopt(cfd, IPPROTO_TCP, TCP_KEEPIDLE, &p->clitcpka_idle, sizeof(p->clitcpka_idle));
BUILD: tcp: condition TCP keepalive settings to platforms providing them Previous commit b24bc0d ("MINOR: tcp: Support TCP keepalive parameters customization") broke non-Linux builds as TCP_KEEP{CNT,IDLE,INTVL} are not necessarily defined elsewhere. This patch adds the required #ifdefs to condition the visibility of the keywords, and adds a mention in the doc about their dependency on Linux.
2020-07-08 23:58:51 -04:00
#endif
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
BUILD: tcp: condition TCP keepalive settings to platforms providing them Previous commit b24bc0d ("MINOR: tcp: Support TCP keepalive parameters customization") broke non-Linux builds as TCP_KEEP{CNT,IDLE,INTVL} are not necessarily defined elsewhere. This patch adds the required #ifdefs to condition the visibility of the keywords, and adds a mention in the doc about their dependency on Linux.
2020-07-08 23:58:51 -04:00
#ifdef TCP_KEEPINTVL
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
if (p->clitcpka_intvl)
setsockopt(cfd, IPPROTO_TCP, TCP_KEEPINTVL, &p->clitcpka_intvl, sizeof(p->clitcpka_intvl));
BUILD: tcp: condition TCP keepalive settings to platforms providing them Previous commit b24bc0d ("MINOR: tcp: Support TCP keepalive parameters customization") broke non-Linux builds as TCP_KEEP{CNT,IDLE,INTVL} are not necessarily defined elsewhere. This patch adds the required #ifdefs to condition the visibility of the keywords, and adds a mention in the doc about their dependency on Linux.
2020-07-08 23:58:51 -04:00
#endif
MINOR: tcp: Support TCP keepalive parameters customization It is now possible to customize TCP keepalive parameters. These correspond to the socket options TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL and are valid for the defaults, listen, frontend and backend sections. This patch fixes GitHub issue #670.
2020-07-08 22:13:20 -04:00
}
MEDIUM: frontend: move the fd-specific settings to session_accept_fd() The frontend is generic and does not depend on a file descriptor, so applying some socket options to the incoming fd is not its role. Let's move the setsockopt() calls earlier in session_accept_fd() where others are done as well.
2015-04-05 11:56:47 -04:00
if (p->options & PR_O_TCP_NOLING)
MINOR: fd: move .linger_risk into fdtab[].state No need to keep this flag apart any more, let's merge it into the global state. The CLI's output state was extended to 6 digits and the linger/cloned flags moved inside the parenthesis.
2021-04-06 11:49:19 -04:00
HA_ATOMIC_OR(&fdtab[cfd].state, FD_LINGER_RISK);
MEDIUM: frontend: move the fd-specific settings to session_accept_fd() The frontend is generic and does not depend on a file descriptor, so applying some socket options to the incoming fd is not its role. Let's move the setsockopt() calls earlier in session_accept_fd() where others are done as well.
2015-04-05 11:56:47 -04:00
#if defined(TCP_MAXSEG)
if (l->maxseg < 0) {
/* we just want to reduce the current MSS by that value */
int mss;
socklen_t mss_len = sizeof(mss);
if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) {
mss += l->maxseg; /* remember, it's < 0 */
setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss));
}
}
#endif
}
if (global.tune.client_sndbuf)
setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf));
if (global.tune.client_rcvbuf)
setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf));
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
/* OK, now either we have a pending handshake to execute with and then
* we must return to the I/O layer, or we can proceed with the end of
* the stream initialization. In case of handshake, we also set the I/O
* timeout to the frontend's client timeout and register a task in the
* session for this purpose. The connection's owner is left to the
* session during this period.
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
*
* At this point we set the relation between sess/task/conn this way :
*
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
* +----------------- task
* | |
* orig -- sess <-- context |
* | ^ | |
* v | | |
* conn -- owner ---> task <-----+
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
*/
MEDIUM: connection: use CO_FL_WAIT_XPRT more consistently than L4/L6/HANDSHAKE As mentioned in commit c192b0ab95 ("MEDIUM: connection: remove CO_FL_CONNECTED and only rely on CO_FL_WAIT_*"), there is a lack of consistency on which flags are checked among L4/L6/HANDSHAKE depending on the code areas. A number of sample fetch functions only check for L4L6 to report MAY_CHANGE, some places only check for HANDSHAKE and many check both L4L6 and HANDSHAKE. This patch starts to make all of this more consistent by introducing a new mask CO_FL_WAIT_XPRT which is the union of L4/L6/HANDSHAKE and reports whether the transport layer is ready or not. All inconsistent call places were updated to rely on this one each time the goal was to check for the readiness of the transport layer.
2020-01-23 10:27:54 -05:00
if (cli_conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)) {
MAJOR: threads/task: handle multithread on task scheduler 2 global locks have been added to protect, respectively, the run queue and the wait queue. And a process mask has been added on each task. Like for FDs, this mask is used to know which threads are allowed to process a task. For many tasks, all threads are granted. And this must be your first intension when you create a new task, else you have a good reason to make a task sticky on some threads. This is then the responsibility to the process callback to lock what have to be locked in the task context. Nevertheless, all tasks linked to a session must be sticky on the thread creating the session. It is important that I/O handlers processing session FDs and these tasks run on the same thread to avoid conflicts.
2017-09-27 08:59:38 -04:00
if (unlikely((sess->task = task_new(tid_bit)) == NULL))
MEDIUM: stream: make stream_new() allocate its own task Currently a task is allocated in session_new() and serves two purposes : - either the handshake is complete and it is offered to the stream via the second arg of stream_new() - or the handshake is not complete and it's diverted to be used as a timeout handler for the embryonic session and repurposed once we land into conn_complete_session() Furthermore, the task's process() function was taken from the listener's handler in conn_complete_session() prior to being replaced by a call to stream_new(). This will become a serious mess with the mux. Since it's impossible to have a stream without a task, this patch removes the second arg from stream_new() and make this function allocate its own task. In session_accept_fd(), we now only allocate the task if needed for the embryonic session and delete it later.
2017-08-28 10:22:54 -04:00
goto out_free_sess;
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
sess->task->context = sess;
sess->task->nice = l->nice;
sess->task->process = session_expire_embryonic;
sess->task->expire = tick_add_ifset(now_ms, p->timeout.client);
task_queue(sess->task);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
return 1;
}
MINOR: session: set the CO_FL_CONNECTED flag on the connection once ready If we know there's no handshake, we must set the flag on the connection, it's not the job of the stream initializer to do it.
2015-04-04 19:04:01 -04:00
/* OK let's complete stream initialization since there is no handshake */
MEDIUM: session: factor out duplicated code for conn_complete_session session_accept_fd() may either successfully complete a session creation, or defer it to conn_complete_session() depending of whether a handshake remains to be performed or not. The problem is that all the code after the handshake was duplicated between the two functions. This patch make session_accept_fd() synchronously call conn_complete_session() to finish the session creation. It is only needed to check if the session's task has to be released or not at the end, which is fairly minimal. This way there is now a single place where the sessions are created.
2017-09-15 04:06:28 -04:00
if (conn_complete_session(cli_conn) >= 0)
return 1;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
BUG/MEDIUM: session: do not report a failure when rejecting a session In session_accept_fd() we can perform a synchronous call to conn_complete_session() and if it succeeds the connection is accepted and turned into a session. If it fails we take it as an error while it is not, in this case, it's just that a tcp-request rule has decided to reject the incoming connection. The problem with reporting such an event as an error is that the failed status is passed down to the listener code which decides to disable accept() for 100ms in order to leave some time for transient issues to vanish, and that's not what we want to do here. This fix must be backported as far as 1.7. In 1.7 the code is a bit different as tcp_exec_l5_rules() is called directly from within session_new_fd() and ret=0 must be assigned there.
2020-01-07 12:03:09 -05:00
/* if we reach here we have deliberately decided not to keep this
* session (e.g. tcp-request rule), so that's not an error we should
* try to protect against.
*/
ret = 0;
MEDIUM: session: factor out duplicated code for conn_complete_session session_accept_fd() may either successfully complete a session creation, or defer it to conn_complete_session() depending of whether a handshake remains to be performed or not. The problem is that all the code after the handshake was duplicated between the two functions. This patch make session_accept_fd() synchronously call conn_complete_session() to finish the session creation. It is only needed to check if the session's task has to be released or not at the end, which is fairly minimal. This way there is now a single place where the sessions are created.
2017-09-15 04:06:28 -04:00
/* error unrolling */
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
out_free_sess:
BUG/MINOR: listener: Don't decrease actconn twice when a new session is rejected When a freshly created session is rejected, for any reason, during the accept in the function "session_accept_fd", the variable "actconn" is decreased twice. The first time when the rejected session is released, then in the function "listener_accpect", because of the failure. So it is possible to have an negative value for actconn. Note that, in this case, we will also have a negatve value for the current number of connections on the listener rejecting the session (actconn and l->nbconn are in/decreased in same time). It is easy to reproduce the bug with this small configuration: global stats socket /tmp/haproxy listen test bind *:12345 tcp-request connection reject if TRUE A "show info" on the stat socket, after a connection attempt, will show a very high value (the unsigned representation of -1). To fix the bug, if the function "session_accept_fd" returns an error, it decrements the right counters and "listener_accpect" leaves them untouched. This patch must be backported in 1.8.
2018-03-23 10:11:55 -04:00
/* prevent call to listener_release during session_free. It will be
* done below, for all errors. */
sess->listener = NULL;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
session_free(sess);
MINOR: session: simplify error path in session_accept_fd() Now that this function is always called with an initialized connection and that the control layer is always initialized, we don't need to play games with fdtab[] to decide how to close, we can simply rely on the regular close path using conn_ctrl_close(), which can be fused with conn_xprt_close() into conn_full_close(). The code is cleaner because the FD is now used only for some protocol-specific setup (that will eventually have to move) and to try to send a hard-coded HTTP 500 error message on raw sockets.
2020-10-15 01:11:14 -04:00
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
out_free_conn:
BUG/MINOR: session: Emit an HTTP error if accept fails only for H1 connection If session_accept_fd() fails for a raw HTTP socket, we try to send an HTTP error 500. But, we must also take care it is an HTTP/1 connection. We cannot rely on the mux at this stage, because the error, if any, happens before or during its creation. So, instead, we check if the mux_proto is specified or not. Indeed, the mux h1 cannot be forced on the bind line and there is no ALPN to choose another mux on a raw socket. So if there is no mux_proto defined for a raw HTTP socket, we are sure to have an HTTP/1 connection. This patch must be backported to 2.0 and 1.9.
2019-07-17 10:53:19 -04:00
if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) &&
p->mode == PR_MODE_HTTP && l->bind_conf->mux_proto == NULL) {
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
/* critical error, no more memory, try to emit a 500 response */
BUG/MINOR: session: Send a default HTTP error if accept fails for a H1 socket If session_accept_fd() fails for a raw HTTP socket, we try to send an HTTP error 500. But we must not rely on error messages of the proxy or on the array http_err_chunks because these are HTX messages. And it should be too expensive to convert an HTX message to a raw message at this place. So instead, we send a default HTTP error message from the array http_err_msgs. This patch must be backported to 2.0 and 1.9.
2019-07-17 15:36:33 -04:00
send(cfd, http_err_msgs[HTTP_ERR_500], strlen(http_err_msgs[HTTP_ERR_500]),
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
MSG_DONTWAIT|MSG_NOSIGNAL);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
}
MINOR: session: simplify error path in session_accept_fd() Now that this function is always called with an initialized connection and that the control layer is always initialized, we don't need to play games with fdtab[] to decide how to close, we can simply rely on the regular close path using conn_ctrl_close(), which can be fused with conn_xprt_close() into conn_full_close(). The code is cleaner because the FD is now used only for some protocol-specific setup (that will eventually have to move) and to try to send a hard-coded HTTP 500 error message on raw sockets.
2020-10-15 01:11:14 -04:00
conn_stop_tracking(cli_conn);
conn_full_close(cli_conn);
conn_free(cli_conn);
listener_release(l);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
return ret;
}
/* prepare the trash with a log prefix for session <sess>. It only works with
* embryonic sessions based on a real connection. This function requires that
* at sess->origin points to the incoming connection.
*/
static void session_prepare_log_prefix(struct session *sess)
{
struct tm tm;
char pn[INET6_ADDRSTRLEN];
int ret;
char *end;
struct connection *cli_conn = __objt_conn(sess->origin);
MINOR: session: use conn->src instead of conn->addr.from In session_accept_fd() we'll soon have to dynamically allocate the address, or better, steal it from the caller and define a strict calling convention regarding who's responsible for the freeing. In the simpler session_prepare_log_prefix(), just add an attempt to retrieve the address if not yet set and do not dereference it on failure.
2019-07-17 09:23:20 -04:00
ret = conn_get_src(cli_conn) ? addr_to_str(cli_conn->src, pn, sizeof(pn)) : 0;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
if (ret <= 0)
chunk_printf(&trash, "unknown [");
else if (ret == AF_UNIX)
chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
else
MINOR: session: use conn->src instead of conn->addr.from In session_accept_fd() we'll soon have to dynamically allocate the address, or better, steal it from the caller and define a strict calling convention regarding who's responsible for the freeing. In the simpler session_prepare_log_prefix(), just add an attempt to retrieve the address if not yet set and do not dereference it on failure.
2019-07-17 09:23:20 -04:00
chunk_printf(&trash, "%s:%d [", pn, get_host_port(cli_conn->src));
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
get_localtime(sess->accept_date.tv_sec, &tm);
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
end = date2str_log(trash.area + trash.data, &tm, &(sess->accept_date),
trash.size - trash.data);
trash.data = end - trash.area;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
if (sess->listener->name)
chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
else
chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
}
/* This function kills an existing embryonic session. It stops the connection's
* transport layer, releases assigned resources, resumes the listener if it was
* disabled and finally kills the file descriptor. This function requires that
* sess->origin points to the incoming connection.
*/
MEDIUM: task: extend the state field to 32 bits It's been too short for quite a while now and is now full. It's still time to extend it to 32-bits since we have room for this without wasting any space, so we now gained 16 new bits for future flags. The values were not reassigned just in case there would be a few hidden u16 or short somewhere in which these flags are placed (as it used to be the case with stream->pending_events). The patch is tagged MEDIUM because this required to update the task's process() prototype to use an int instead of a short, that's quite a bunch of places.
2021-03-02 10:09:26 -05:00
static void session_kill_embryonic(struct session *sess, unsigned int state)
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
{
int level = LOG_INFO;
struct connection *conn = __objt_conn(sess->origin);
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
struct task *task = sess->task;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
unsigned int log = sess->fe->to_log;
const char *err_msg;
if (sess->fe->options2 & PR_O2_LOGERRORS)
level = LOG_ERR;
if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
/* with "option dontlognull", we don't log connections with no transfer */
if (!conn->err_code ||
conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
MINOR: listener: add the "accept-netscaler-cip" option to the "bind" keyword When NetScaler application switch is used as L3+ switch, informations regarding the original IP and TCP headers are lost as a new TCP connection is created between the NetScaler and the backend server. NetScaler provides a feature to insert in the TCP data the original data that can then be consumed by the backend server. Specifications and documentations from NetScaler: https://support.citrix.com/article/CTX205670 https://www.citrix.com/blogs/2016/04/25/how-to-enable-client-ip-in-tcpip-option-of-netscaler/ When CIP is enabled on the NetScaler, then a TCP packet is inserted just after the TCP handshake. This is composed as: - CIP magic number : 4 bytes Both sender and receiver have to agree on a magic number so that they both handle the incoming data as a NetScaler Client IP insertion packet. - Header length : 4 bytes Defines the length on the remaining data. - IP header : >= 20 bytes if IPv4, 40 bytes if IPv6 Contains the header of the last IP packet sent by the client during TCP handshake. - TCP header : >= 20 bytes Contains the header of the last TCP packet sent by the client during TCP handshake.
2016-06-04 10:11:10 -04:00
conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
log = 0;
}
if (log) {
BUG/MINOR: tasks: make sure wakeup events are properly reported to subscribers The tasks API was changed in 1.9-dev1 with commit 9f6af3322 ("MINOR: tasks: Change the task API so that the callback takes 3 arguments."), causing the task's state not to be usable anymore and to have been replaced with an explicit argument in the callee. The task's state doesn't contain any trace of the wakeup cause anymore. But there were two places where the old task's state remained in use : - sessions, used to more accurately report timeouts in logs when seeing TASK_WOKEN_TIMEOUT ; - peers, used to finish resynchronization when seeing TASK_WOKEN_SIGNAL This commit fixes both occurrences by making sure we don't access task->state directly (should we rename it by the way ?). No backport is needed.
2018-11-05 09:09:47 -05:00
if (!conn->err_code && (state & TASK_WOKEN_TIMER)) {
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
if (conn->flags & CO_FL_ACCEPT_PROXY)
conn->err_code = CO_ER_PRX_TIMEOUT;
MINOR: listener: add the "accept-netscaler-cip" option to the "bind" keyword When NetScaler application switch is used as L3+ switch, informations regarding the original IP and TCP headers are lost as a new TCP connection is created between the NetScaler and the backend server. NetScaler provides a feature to insert in the TCP data the original data that can then be consumed by the backend server. Specifications and documentations from NetScaler: https://support.citrix.com/article/CTX205670 https://www.citrix.com/blogs/2016/04/25/how-to-enable-client-ip-in-tcpip-option-of-netscaler/ When CIP is enabled on the NetScaler, then a TCP packet is inserted just after the TCP handshake. This is composed as: - CIP magic number : 4 bytes Both sender and receiver have to agree on a magic number so that they both handle the incoming data as a NetScaler Client IP insertion packet. - Header length : 4 bytes Defines the length on the remaining data. - IP header : >= 20 bytes if IPv4, 40 bytes if IPv6 Contains the header of the last IP packet sent by the client during TCP handshake. - TCP header : >= 20 bytes Contains the header of the last TCP packet sent by the client during TCP handshake.
2016-06-04 10:11:10 -04:00
else if (conn->flags & CO_FL_ACCEPT_CIP)
conn->err_code = CO_ER_CIP_TIMEOUT;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
else if (conn->flags & CO_FL_SSL_WAIT_HS)
conn->err_code = CO_ER_SSL_TIMEOUT;
}
session_prepare_log_prefix(sess);
err_msg = conn_err_code_str(conn);
if (err_msg)
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
send_log(sess->fe, level, "%s: %s\n", trash.area,
err_msg);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
else
send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
trash.area, conn->err_code, conn->flags);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
}
/* kill the connection now */
MINOR: session: use conn_full_close() instead of conn_force_close() We simply disable tracking before calling it.
2017-10-05 12:12:51 -04:00
conn_stop_tracking(conn);
conn_full_close(conn);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
conn_free(conn);
MAJOR: connections: Detach connections from streams. Do not destroy the connection when we're about to destroy a stream. This prevents us from doing keepalive on server connections when the client is using HTTP/2, as a new stream is created for each request. Instead, the session is now responsible for destroying connections. When reusing connections, the attach() mux method is now used to create a new conn_stream.
2018-11-13 10:48:36 -05:00
sess->origin = NULL;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
MEDIUM: tasks: Merge task_delete() and task_free() into task_destroy(). task_delete() was never used without calling task_free() just after, and task_free() was only used on error pathes to destroy a just-created task, so merge them into task_destroy(), that will remove the task from the wait queue, and make sure the task is either destroyed immediately if it's not in the run queue, or destroyed when it's supposed to run.
2019-04-17 16:51:06 -04:00
task_destroy(task);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
session_free(sess);
}
/* Manages the embryonic session timeout. It is only called when the timeout
MINOR: session: export session_expire_embryonic() This is only to make it resolve nicely in "show tasks".
2021-01-29 06:27:57 -05:00
* strikes and performs the required cleanup. It's only exported to make it
* resolve in "show tasks".
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
*/
MEDIUM: task: extend the state field to 32 bits It's been too short for quite a while now and is now full. It's still time to extend it to 32-bits since we have room for this without wasting any space, so we now gained 16 new bits for future flags. The values were not reassigned just in case there would be a few hidden u16 or short somewhere in which these flags are placed (as it used to be the case with stream->pending_events). The patch is tagged MEDIUM because this required to update the task's process() prototype to use an int instead of a short, that's quite a bunch of places.
2021-03-02 10:09:26 -05:00
struct task *session_expire_embryonic(struct task *t, void *context, unsigned int state)
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
{
MINOR: tasks: Change the task API so that the callback takes 3 arguments. In preparation for thread-specific runqueues, change the task API so that the callback takes 3 arguments, the task itself, the context, and the state, those were retrieved from the task before. This will allow these elements to change atomically in the scheduler while the application uses the copied value, and even to have NULL tasks later.
2018-05-25 08:04:04 -04:00
struct session *sess = context;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
BUG/MEDIUM: sessions: Don't use t->state. In session_expire_embryonic(), don't use t->state, use the "state" argument instead, as t->state has been cleaned before we're being called.
2018-08-16 13:03:50 -04:00
if (!(state & TASK_WOKEN_TIMER))
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
return t;
BUG/MINOR: tasks: make sure wakeup events are properly reported to subscribers The tasks API was changed in 1.9-dev1 with commit 9f6af3322 ("MINOR: tasks: Change the task API so that the callback takes 3 arguments."), causing the task's state not to be usable anymore and to have been replaced with an explicit argument in the callee. The task's state doesn't contain any trace of the wakeup cause anymore. But there were two places where the old task's state remained in use : - sessions, used to more accurately report timeouts in logs when seeing TASK_WOKEN_TIMEOUT ; - peers, used to finish resynchronization when seeing TASK_WOKEN_SIGNAL This commit fixes both occurrences by making sure we don't access task->state directly (should we rename it by the way ?). No backport is needed.
2018-11-05 09:09:47 -05:00
session_kill_embryonic(sess, state);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
return NULL;
}
/* Finish initializing a session from a connection, or kills it if the
MEDIUM: session: factor out duplicated code for conn_complete_session session_accept_fd() may either successfully complete a session creation, or defer it to conn_complete_session() depending of whether a handshake remains to be performed or not. The problem is that all the code after the handshake was duplicated between the two functions. This patch make session_accept_fd() synchronously call conn_complete_session() to finish the session creation. It is only needed to check if the session's task has to be released or not at the end, which is fairly minimal. This way there is now a single place where the sessions are created.
2017-09-15 04:06:28 -04:00
* connection shows and error. Returns <0 if the connection was killed. It may
MEDIUM: connections: Get ride of the xprt_done callback. The xprt_done_cb callback was used to defer some connection initialization until we're connected and the handshake are done. As it mostly consists of creating the mux, instead of using the callback, introduce a conn_create_mux() function, that will just call conn_complete_session() for frontend, and create the mux for backend. In h2_wake(), make sure we call the wake method of the stream_interface, as we no longer wakeup the stream task.
2020-01-22 12:08:48 -05:00
* be called either asynchronously when ssl handshake is done with an embryonic
MEDIUM: session: factor out duplicated code for conn_complete_session session_accept_fd() may either successfully complete a session creation, or defer it to conn_complete_session() depending of whether a handshake remains to be performed or not. The problem is that all the code after the handshake was duplicated between the two functions. This patch make session_accept_fd() synchronously call conn_complete_session() to finish the session creation. It is only needed to check if the session's task has to be released or not at the end, which is fairly minimal. This way there is now a single place where the sessions are created.
2017-09-15 04:06:28 -04:00
* session, or synchronously to finalize the session. The distinction is made
* on sess->task which is only set in the embryonic session case.
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
*/
MEDIUM: connections: Get ride of the xprt_done callback. The xprt_done_cb callback was used to defer some connection initialization until we're connected and the handshake are done. As it mostly consists of creating the mux, instead of using the callback, introduce a conn_create_mux() function, that will just call conn_complete_session() for frontend, and create the mux for backend. In h2_wake(), make sure we call the wake method of the stream_interface, as we no longer wakeup the stream task.
2020-01-22 12:08:48 -05:00
int conn_complete_session(struct connection *conn)
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
{
MEDIUM: session: add a pointer to a struct task in the session The session may need to enforce a timeout when waiting for a handshake. Till now we used a trick to avoid allocating a pointer, we used to set the connection's owner to the task and set the task's context to the session, so that it was possible to circle between all of them. The problem is that we'll really need to pass the pointer to the session to the upper layers during initialization and that the only place to store it is conn->owner, which is squatted for this trick. So this patch moves the struct task* into the session where it should always have been and ensures conn->owner points to the session until the data layer is properly initialized.
2017-08-28 13:02:51 -04:00
struct session *sess = conn->owner;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
BUG/MEDIUM: session: fix reporting of handshake processing time in the logs The handshake processing time used to be stored per stream, which was valid when there was exactly one stream per session. With H2 and multiplexing it's not the case anymore and the reported handshake times are wrong in the logs as it's computed between the TCP accept() and the stream creation. Let's first move the handshake where it belongs, which is the session. However, this is not enough because we don't want to report an excessive idle time either for H2 (since many requests use the connection). So the solution used here is to have the stream retrieve sess->tv_accept and the handshake duration when the stream is created, and let the mux immediately reset them. This way, the handshake time becomes zero for the second and subsequent requests in H2 (which was already the case in H1), and the idle time exactly counts how long the connection remained unused while it could be used, so in H1 it runs from the end of the previous response and in H2 it runs from the end of the previous request since the channel is already available. This patch will need to be backported to 1.8.
2018-09-05 05:56:48 -04:00
sess->t_handshake = tv_ms_elapsed(&sess->tv_accept, &now);
MEDIUM: stream: don't rely on the session's listener anymore in stream_new() When the stream is instanciated from an applet, it doesn't necessarily have a listener. The listener was sparsely used there, just to retrieve the task function, update the listeners' stats, and set the analysers and default target, both of which are often zero from applets. Thus these elements are now initialized with default values that the caller is free to change if desired.
2015-04-05 18:25:48 -04:00
if (conn->flags & CO_FL_ERROR)
goto fail;
MEDIUM: session: adjust the connection flags before stream_new() It's not the stream's job to manipulate the connection's flags, it's more related to the session that accepted the new connection. And the only case where we have to do it conditionally is based on the frontend which is known from the session, thus it makes sense to do it there.
2015-04-08 12:18:15 -04:00
/* if logs require transport layer information, note it on the connection */
if (sess->fe->to_log & LW_XPRT)
conn->flags |= CO_FL_XPRT_TRACKED;
MEDIUM: tcp: add registration and processing of TCP L5 rules This commit introduces "tcp-request session" rules. These are very much like "tcp-request connection" rules except that they're processed after the handshake, so it is possible to consider SSL information and addresses rewritten by the proxy protocol header in actions. This is particularly useful to track proxied sources as this was not possible before, given that tcp-request content rules are processed after each HTTP request. Similarly it is possible to assign the proxied source address or the client's cert to a variable.
2016-10-21 10:37:51 -04:00
/* we may have some tcp-request-session rules */
if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
goto fail;
MINOR: session: maintain the session count stats in the session, not the stream This has nothing to do in the stream, as we'll face absurdities when chaining multiple streams. The session is where it must be accounted for.
2015-04-08 12:10:49 -04:00
session_count_new(sess);
MEDIUM: mux: Use the mux protocol specified on bind/server lines To do so, mux choices are split to handle incoming and outgoing connections in a different way. The protocol specified on the bind/server line is used in priority. Then, for frontend connections, the ALPN is retrieved and used to choose the best mux. For backend connection, there is no ALPN. Finaly, if no protocol is specified and no protocol matches the ALPN, we fall back on a default mux, choosing in priority the first mux with exactly the same mode.
2018-04-10 09:01:45 -04:00
if (conn_install_mux_fe(conn, NULL) < 0)
MEDIUM: stream: don't rely on the session's listener anymore in stream_new() When the stream is instanciated from an applet, it doesn't necessarily have a listener. The listener was sparsely used there, just to retrieve the task function, update the listeners' stats, and set the analysers and default target, both of which are often zero from applets. Thus these elements are now initialized with default values that the caller is free to change if desired.
2015-04-05 18:25:48 -04:00
goto fail;
MEDIUM: stream: make stream_new() allocate its own task Currently a task is allocated in session_new() and serves two purposes : - either the handshake is complete and it is offered to the stream via the second arg of stream_new() - or the handshake is not complete and it's diverted to be used as a timeout handler for the embryonic session and repurposed once we land into conn_complete_session() Furthermore, the task's process() function was taken from the listener's handler in conn_complete_session() prior to being replaced by a call to stream_new(). This will become a serious mess with the mux. Since it's impossible to have a stream without a task, this patch removes the second arg from stream_new() and make this function allocate its own task. In session_accept_fd(), we now only allocate the task if needed for the embryonic session and delete it later.
2017-08-28 10:22:54 -04:00
/* the embryonic session's task is not needed anymore */
CLEANUP: task: remove unneeded tests before task_destroy() Since previous commit it's not needed anymore to test a task pointer before calling task_destory() so let's just remove these tests from the various callers before they become confusing. The function's arguments were also documented. The same should probably be done with tasklet_free() which involves a test in roughly half of the call places.
2019-05-07 13:05:35 -04:00
task_destroy(sess->task);
sess->task = NULL;
MEDIUM: session: make use of the connection's destroy callback Now we don't remove the session when a stream dies, instead we detach the stream and let the mux decide to release the connection and call session_free() instead.
2017-10-08 05:26:30 -04:00
conn_set_owner(conn, sess, conn_session_free);
MEDIUM: stream: don't rely on the session's listener anymore in stream_new() When the stream is instanciated from an applet, it doesn't necessarily have a listener. The listener was sparsely used there, just to retrieve the task function, update the listeners' stats, and set the analysers and default target, both of which are often zero from applets. Thus these elements are now initialized with default values that the caller is free to change if desired.
2015-04-05 18:25:48 -04:00
return 0;
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
MEDIUM: stream: don't rely on the session's listener anymore in stream_new() When the stream is instanciated from an applet, it doesn't necessarily have a listener. The listener was sparsely used there, just to retrieve the task function, update the listeners' stats, and set the analysers and default target, both of which are often zero from applets. Thus these elements are now initialized with default values that the caller is free to change if desired.
2015-04-05 18:25:48 -04:00
fail:
MEDIUM: session: factor out duplicated code for conn_complete_session session_accept_fd() may either successfully complete a session creation, or defer it to conn_complete_session() depending of whether a handshake remains to be performed or not. The problem is that all the code after the handshake was duplicated between the two functions. This patch make session_accept_fd() synchronously call conn_complete_session() to finish the session creation. It is only needed to check if the session's task has to be released or not at the end, which is fairly minimal. This way there is now a single place where the sessions are created.
2017-09-15 04:06:28 -04:00
if (sess->task)
BUG/MINOR: tasks: make sure wakeup events are properly reported to subscribers The tasks API was changed in 1.9-dev1 with commit 9f6af3322 ("MINOR: tasks: Change the task API so that the callback takes 3 arguments."), causing the task's state not to be usable anymore and to have been replaced with an explicit argument in the callee. The task's state doesn't contain any trace of the wakeup cause anymore. But there were two places where the old task's state remained in use : - sessions, used to more accurately report timeouts in logs when seeing TASK_WOKEN_TIMEOUT ; - peers, used to finish resynchronization when seeing TASK_WOKEN_SIGNAL This commit fixes both occurrences by making sure we don't access task->state directly (should we rename it by the way ?). No backport is needed.
2018-11-05 09:09:47 -05:00
session_kill_embryonic(sess, 0);
REORG: session: move the session parts out of stream.c This concerns everythins related to accepting a new session and expiring the embryonic session. There's still a hard-coded call to stream_accept_session() which could be set somewhere in the frontend, but for now it's not a problem.
2015-04-04 12:50:31 -04:00
return -1;
}
MINOR: session: start to reintroduce struct session There is now a pointer to the session in the stream, which is NULL for now. The session pool is created as well. Some parts will move from the stream to the session now.
2015-04-03 07:53:24 -04:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink