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

359 lines
10 KiB
C
Raw Normal View History

[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
/*
[CLEANUP] rename client -> frontend The 'client.c' file now only contained frontend-specific functions, so it has naturally be renamed 'frontend.c'. Same for client.h. This has also been an opportunity to remove some cross references from files that should not have depended on it. In the end, this file should contain a protocol-agnostic accept() code, which would initialize a session, task, etc... based on an accept() from a lower layer. Right now there are still references to TCP.
2010-05-24 15:02:37 -04:00
* Frontend variables and functions.
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
*
MINOR: frontend: rename sample fetch functions and declare the sample keywords The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : fe_conn, fe_id, fe_sess_rate The fetch functions have been renamed "smp_fetch_*".
2013-01-07 16:48:29 -05:00
* Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -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.
*
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 11:53:05 -04:00
#include <string.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
[MINOR] tcp: add support for dynamic MSS setting By passing a negative value to the "mss" argument of "bind" lines, it becomes possible to subtract this value to the MSS advertised by the client, which results in segments smaller than advertised. The effect is useful with some TCP stacks which ACK less often when segments are not full, because they only ACK every other full segment as suggested by RFC1122. NOTE: currently this has no effect on Linux kernel 2.6, a kernel patch is still required to change the MSS of established connections.
2010-12-24 09:26:39 -05:00
#include <netinet/tcp.h>
REORG: include: move acl.h to haproxy/acl.h{,-t}.h The files were moved almost as-is, just dropping arg-t and auth-t from acl-t but keeping arg-t in acl.h. It was useful to revisit the call places since a handful of files used to continue to include acl.h while they did not need it at all. Struct stream was only made a forward declaration since not otherwise needed.
2020-06-04 13:11:43 -04:00
#include <haproxy/acl.h>
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>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/arg.h>
REORG: include: move common/chunk.h to haproxy/chunk.h No change was necessary, it was already properly split.
2020-06-02 04:22:45 -04:00
#include <haproxy/chunk.h>
MEDIUM: stream-int/conn-stream: Move src/dst addresses in the conn-stream The source and destination addresses at the applicative layer are moved from the stream-interface to the conn-stream. This simplifies a bit the code and it is a logicial step to remove the stream-interface.
2022-03-29 11:53:09 -04:00
#include <haproxy/connection.h>
MAJOR: counters: dispatch counters over thread groups Most fe and be counters are good candidates for being shared between processes. They are now grouped inside "shared" struct sub member under be_counters and fe_counters. Now they are properly identified, they would greatly benefit from being shared over thread groups to reduce the cost of atomic operations when updating them. For this, we take the current tgid into account so each thread group only updates its own counters. For this to work, it is mandatory that the "shared" member from {fe,be}_counters is initialized AFTER global.nbtgroups is known, because each shared counter causes the stat to be allocated lobal.nbtgroups times. When updating a counter without concurrency, the first counter from the array may be updated. To consult the shared counters (which requires aggregation of per-tgid individual counters), some helper functions were added to counter.h to ease code maintenance and avoid computing errors.
2025-05-15 13:55:11 -04:00
#include <haproxy/counters.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/fd.h>
REORG: include: move frontend.h to haproxy/frontend.h There was no type file for this one, it only contains frontend_accept().
2020-06-04 05:23:07 -04:00
#include <haproxy/frontend.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/global.h>
REORG: include: move http_ana.h to haproxy/http_ana{,-t}.h It was moved without any change, however many callers didn't need it at all. This was a consequence of the split of proto_http.c into several parts that resulted in many locations to still reference it.
2020-06-04 15:21:03 -04:00
#include <haproxy/http_ana.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>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/proto_tcp.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 sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
#include <haproxy/sample.h>
REORG: rename cs_utils.h to sc_strm.h This file contains all the stream-connector functions that are specific to application layers of type stream. So let's name it accordingly so that it's easier to figure what's located there. The alphabetical ordering of include files was preserved.
2022-05-27 03:25:10 -04:00
#include <haproxy/sc_strm.h>
REORG: include: move stream.h to haproxy/stream{,-t}.h This one was not easy because it was embarking many includes with it, which other files would automatically find. At least global.h, arg.h and tools.h were identified. 93 total locations were identified, 8 additional includes had to be added. In the rare files where it was possible to finalize the sorting of includes by adjusting only one or two extra lines, it was done. But all files would need to be rechecked and cleaned up now. It was the last set of files in types/ and proto/ and these directories must not be reused anymore.
2020-06-04 17:46:14 -04:00
#include <haproxy/stream.h>
REORG: include: move task.h to haproxy/task{,-t}.h The TASK_IS_TASKLET() macro was moved to the proto file instead of the type one. The proto part was a bit reordered to remove a number of ugly forward declaration of static inline functions. About a tens of C and H files had their dependency dropped since they were not using anything from task.h.
2020-06-04 11:25:40 -04:00
#include <haproxy/task.h>
CLEANUP: tree-wide: remove unneeded include time.h in ~20 files 20 files used to have haproxy/time.h included only for now_ms, and two were missing it for other things but used to inherit from it via other files.
2021-10-06 10:18:40 -04:00
#include <haproxy/ticks.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/tools.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
/* Finish a stream accept() for a proxy (TCP or HTTP). It returns a negative
[BUG] accept: don't close twice upon error The stream_sock's accept() used to close the FD upon error, but this was also sometimes performed by the frontend's accept() called via the session's accept(). Those interlaced calls were also responsible for the spaghetti-looking error unrolling code in session.c and stream_sock.c. Now the frontend must not close the FD anymore, the session is responsible for that. It also takes care of just closing the FD or also removing from the FD lists, depending on its state. The socket-level accept() does not have to care about that anymore.
2010-11-11 04:56:04 -05:00
* value in case of a critical failure which must cause the listener to be
MEDIUM: frontend: don't restrict frontend_accept() to connections anymore Now it can also initialize streams initiated by applets. This will be needed for HTTP/2.
2015-04-05 12:01:06 -04:00
* disabled, a positive or null value in case of success.
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
*/
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
int frontend_accept(struct stream *s)
[MEDIUM] separate protocol-level accept() from the frontend's For a long time we had two large accept() functions, one for TCP sockets instanciating proxies, and another one for UNIX sockets instanciating the stats interface. A lot of code was duplicated and both did not work exactly the same way. Now we have a stream_sock layer accept() called for either TCP or UNIX sockets, and this function calls the frontend-specific accept() function which does the rest of the frontend-specific initialisation. Some code is still duplicated (session & task allocation, stream interface initialization), and might benefit from having an intermediate session-level accept() callback to perform such initializations. Still there are some minor differences that need to be addressed first. For instance, the monitor nets should only be checked for proxies and not for other connection templates. Last, we renamed l->private as l->frontend. The "private" pointer in the listener is only used to store a frontend, so let's rename it to eliminate this ambiguity. When we later support detached listeners (eg: FTP), we'll add another field to avoid the confusion.
2010-05-28 12:46:57 -04:00
{
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
const struct sockaddr_storage *src, *dst;
MEDIUM: stream: move the frontend's pointer to the session Just like for the listener, the frontend is session-wide so let's move it to the session. There are a lot of places which were changed but the changes are minimal in fact.
2015-04-03 09:40:56 -04:00
struct session *sess = s->sess;
MEDIUM: frontend: don't restrict frontend_accept() to connections anymore Now it can also initialize streams initiated by applets. This will be needed for HTTP/2.
2015-04-05 12:01:06 -04:00
struct connection *conn = objt_conn(sess->origin);
MEDIUM: stream: move the frontend's pointer to the session Just like for the listener, the frontend is session-wide so let's move it to the session. There are a lot of places which were changed but the changes are minimal in fact.
2015-04-03 09:40:56 -04:00
struct listener *l = sess->listener;
struct proxy *fe = sess->fe;
MEDIUM: stream: move the listener's pointer to the session The listener is session-specific, move it there.
2015-04-03 08:46:27 -04:00
MEDIUM: stream: move the frontend's pointer to the session Just like for the listener, the frontend is session-wide so let's move it to the session. There are a lot of places which were changed but the changes are minimal in fact.
2015-04-03 09:40:56 -04:00
if ((fe->mode == PR_MODE_TCP || fe->mode == PR_MODE_HTTP)
MEDIUM: tree-wide: logsrv struct becomes logger When 'log' directive was implemented, the internal representation was named 'struct logsrv', because the 'log' directive would directly point to the log target, which used to be a (UDP) log server exclusively at that time, hence the name. But things have become more complex, since today 'log' directive can point to ring targets (implicit, or named) for example. Indeed, a 'log' directive does no longer reference the "final" server to which the log will be sent, but instead it describes which log API and parameters to use for transporting the log messages to the proper log destination. So now the term 'logsrv' is rather confusing and prevents us from introducing a new level of abstraction because they would be mixed with logsrv. So in order to better designate this 'log' directive, and make it more generic, we chose the word 'logger' which now replaces logsrv everywhere it was used in the code (including related comments). This is internal rewording, so no functional change should be expected on user-side.
2023-09-11 09:06:53 -04:00
&& (!LIST_ISEMPTY(&fe->loggers))) {
MEDIUM: log: consider log-steps proxy setting for existing log origins During tcp/http transaction processing, haproxy may produce logs at different steps during the processing (accept, connect, request, response, close). But the behavior is hardly configurable because haproxy will only emit a single log per transaction, and by default it will try to produce the log once all log aliases or fetches used in the logformat could be satisfied, which means the log is often emitted during connection teardown, unless "option logasap" is used. We were often asked to have a way to emit multiple logs for a single transaction, like for instance emit log during accept, then request, response and close for instance, see GH #401 for more context. Thanks to "log-steps" keyword introduced by commit "MINOR: log: introduce "log-steps" proxy keyword", it is now possible to explictly configure when logs should be generated by haproxy when processing a transaction. This commit adds the required checks so that log-steps proxy option is properly considered for existing logs generated by haproxy. If "log-steps" is not specified on the proxy, the old behavior is preserved. Note: a slight cpu overhead should only be visible when "log-steps" keyword will be used due to the implementation relying on eb32 lookup instead of basic bitfield check as described in "MINOR: proxy: add log_steps struct member". However, the default behavior shouldn't be affected. When combining log-steps with log-profiles, user has the ability to explicitly control how and when haproxy should generate logs during requests handling.
2024-09-04 09:03:46 -04:00
if (fe->to_log == LW_LOGSTEPS) {
if (log_orig_proxy(LOG_ORIG_TXN_ACCEPT, fe))
s->do_log(s, log_orig(LOG_ORIG_TXN_ACCEPT, LOG_ORIG_FL_NONE));
}
else if (likely(!lf_expr_isempty(&fe->logformat))) {
[MEDIUM] separate protocol-level accept() from the frontend's For a long time we had two large accept() functions, one for TCP sockets instanciating proxies, and another one for UNIX sockets instanciating the stats interface. A lot of code was duplicated and both did not work exactly the same way. Now we have a stream_sock layer accept() called for either TCP or UNIX sockets, and this function calls the frontend-specific accept() function which does the rest of the frontend-specific initialisation. Some code is still duplicated (session & task allocation, stream interface initialization), and might benefit from having an intermediate session-level accept() callback to perform such initializations. Still there are some minor differences that need to be addressed first. For instance, the monitor nets should only be checked for proxies and not for other connection templates. Last, we renamed l->private as l->frontend. The "private" pointer in the listener is only used to store a frontend, so let's rename it to eliminate this ambiguity. When we later support detached listeners (eg: FTP), we'll add another field to avoid the confusion.
2010-05-28 12:46:57 -04:00
/* we have the client ip */
if (s->logs.logwait & LW_CLIP)
BUG/MINOR: log: make log-format, unique-id-format and add-header more independant It happens that all of them call parse_logformat_line() which sets proxy->to_log with a number of flags affecting the line format for all three users. For example, having a unique-id specified disables the default log-format since fe->to_log is tested when the session is established. Similarly, having "option logasap" will cause "+" to be inserted in unique-id or headers referencing some of the fields depending on LW_BYTES. This patch first removes most of the dependency on fe->to_log whenever possible. The first possible cleanup is to stop checking fe->to_log for being null, considering that it always contains at least LW_INIT when any such usage is made of the log-format! Also, some checks are wrong. s->logs.logwait cannot be nulled by "logwait &= ~LW_*" since LW_INIT is always there. This results in getting the wrong log at the end of a request or session when a unique-id or add-header is set, because logwait is still not null but the log-format is not checked. Further cleanups are required. Most LW_* flags should be removed or at least replaced with what they really mean (eg: depend on client-side connection, depend on server-side connection, etc...) and this should only affect logging, not other mechanisms. This patch fixes the default log-format and tries to limit interferences between the log formats, but does not pretend to do more for the moment, since it's the most visible breakage.
2012-12-28 03:40:16 -05:00
if (!(s->logs.logwait &= ~(LW_CLIP|LW_INIT)))
MINOR: log: introduce log_orig flags Rename 'enum log_orig' to 'enum log_orig_id', since this enum specifically contains the log origin ids. Add 'struct log_orig' which wraps 'enum log_orig' with optional flags (no flags defined for now). Add log_orig() helper func that takes id and flags as parameter and returns log_orig struct initialized with input arguments. Update functions taking log origin as parameter so they explicitly take log orig id or log orig wrapper as argument depending on the level of context expected by the function.
2024-09-23 11:22:45 -04:00
s->do_log(s, log_orig(LOG_ORIG_TXN_ACCEPT, LOG_ORIG_FL_NONE));
[MINOR] http: rely on proxy->acl_requires to allocate hdr_idx Right now only HTTP proxies may use HTTP headers in ACLs, but when this evolves, we'll need to be able to allocate the hdr_idx on demand. The solution consists in allocating it only when it is certain that at least one ACL requires HTTP parsing, regardless of the mode the proxy is in. This is what is achieved by this patch.
2009-07-10 17:52:51 -04:00
}
MEDIUM: frontend: don't restrict frontend_accept() to connections anymore Now it can also initialize streams initiated by applets. This will be needed for HTTP/2.
2015-04-05 12:01:06 -04:00
else if (conn) {
CLEANUP: stconn: rename cs{,_get}_{src,dst} to sc_* The following functions were renamed: cs_src() -> sc_src() cs_dst() -> sc_dst() cs_get_src() -> sc_get_src() cs_get_dst() -> sc_get_dst()
2022-05-27 02:57:21 -04:00
src = sc_src(s->scf);
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
if (!src)
send_log(fe, LOG_INFO, "Connect from unknown source to listener %d (%s/%s)\n",
l->luid, fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
else {
char pn[INET6_ADDRSTRLEN], sn[INET6_ADDRSTRLEN];
int port;
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
switch (addr_to_str(src, pn, sizeof(pn))) {
case AF_INET:
case AF_INET6:
CLEANUP: stconn: rename cs{,_get}_{src,dst} to sc_* The following functions were renamed: cs_src() -> sc_src() cs_dst() -> sc_dst() cs_get_src() -> sc_get_src() cs_get_dst() -> sc_get_dst()
2022-05-27 02:57:21 -04:00
dst = sc_dst(s->scf);
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
if (dst) {
addr_to_str(dst, sn, sizeof(sn));
port = get_host_port(dst);
} else {
CLEANUP: tree-wide: remove strpcy() from constant strings These ones are genenerally harmless on modern compilers because the compiler checks them. While gcc optimizes them away without even referencing strcpy(), clang prefers to call strcpy(). Nevertheless they prevent from enabling stricter checks so better remove them altogether. They were all replaced by strlcpy2() and the size of the destination which is always known there.
2023-04-07 12:11:39 -04:00
strlcpy2(sn, "undetermined address", sizeof(sn));
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
port = 0;
}
send_log(fe, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
pn, get_host_port(src),
sn, port,
fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
break;
case AF_UNIX:
MEDIUM: protocol: make abns a custom unix socket address family This is a pre-requisite to adding the abnsz socket address family: in this patch we make use of protocol API rework started by 732913f ("MINOR: protocol: properly assign the sock_domain and sock_family") in order to implement a dedicated address family for ABNS sockets (based on UNIX parent family). Thanks to this, it will become trivial to implement a new ABNSZ (for abns zero) family which is essentially the same as ABNS but with a slight difference when it comes to path handling (ABNS uses the whole sun_path length, while ABNSZ's path is zero terminated and evaluation stops at 0) It was verified that this patch doesn't break reg-tests and behaves properly (tests performed on the CLI with show sess and show fd). Anywhere relevant, AF_CUST_ABNS is handled alongside AF_UNIX. If no distinction needs to be made, real_family() is used to fetch the proper real family type to handle it properly. Both stream and dgram were converted, so no functional change should be expected for this "internal" rework, except that proto will be displayed as "abns_{stream,dgram}" instead of "unix_{stream,dgram}". Before ("show sess" output): 0x64c35528aab0: proto=unix_stream src=unix:1 fe=GLOBAL be=<NONE> srv=<none> ts=00 epoch=0 age=0s calls=1 rate=0 cpu=0 lat=0 rq[f=848000h,i=0,an=00h,ax=] rp[f=80008000h,i=0,an=00h,ax=] scf=[8,0h,fd=21,rex=10s,wex=] scb=[8,1h,fd=-1,rex=,wex=] exp=10s rc=0 c_exp= After: 0x619da7ad74c0: proto=abns_stream src=unix:1 fe=GLOBAL be=<NONE> srv=<none> ts=00 epoch=0 age=0s calls=1 rate=0 cpu=0 lat=0 rq[f=848000h,i=0,an=00h,ax=] rp[f=80008000h,i=0,an=00h,ax=] scf=[8,0h,fd=22,rex=10s,wex=] scb=[8,1h,fd=-1,rex=,wex=] exp=10s rc=0 c_exp= Co-authored-by: Aurelien DARRAGON <adarragon@haproxy.com>
2024-08-09 12:48:14 -04:00
case AF_CUST_ABNS:
MINOR: protocol: create abnsz socket address family For now it's the same as abns. We'll need to modify sock_unix_addrcmp(), and a few other ones to support effective path length when dealing with the \0. Let's check with Tristan's patch for this (upcoming patch). Co-authored-by: Aurelien DARRAGON <adarragon@haproxy.com>
2024-08-09 15:12:23 -04:00
case AF_CUST_ABNSZ:
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
/* UNIX socket, only the destination is known */
send_log(fe, LOG_INFO, "Connect to unix:%d (%s/%s)\n",
l->luid,
fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
break;
MINOR: frontend: switch to conn_get_{src,dst}() for logging and debugging The frontend accept code uses conn_get_{from,to}_addr for logging and debugging, without really checking if the operation succeeds. In preparation of future changes, let's switch to conn_get_{src,dst}() and integrate status check for possible failures.
2019-07-17 05:25:46 -04:00
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
}
}
[MEDIUM] separate protocol-level accept() from the frontend's For a long time we had two large accept() functions, one for TCP sockets instanciating proxies, and another one for UNIX sockets instanciating the stats interface. A lot of code was duplicated and both did not work exactly the same way. Now we have a stream_sock layer accept() called for either TCP or UNIX sockets, and this function calls the frontend-specific accept() function which does the rest of the frontend-specific initialisation. Some code is still duplicated (session & task allocation, stream interface initialization), and might benefit from having an intermediate session-level accept() callback to perform such initializations. Still there are some minor differences that need to be addressed first. For instance, the monitor nets should only be checked for proxies and not for other connection templates. Last, we renamed l->private as l->frontend. The "private" pointer in the listener is only used to store a frontend, so let's rename it to eliminate this ambiguity. When we later support detached listeners (eg: FTP), we'll add another field to avoid the confusion.
2010-05-28 12:46:57 -04:00
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MEDIUM: frontend: don't restrict frontend_accept() to connections anymore Now it can also initialize streams initiated by applets. This will be needed for HTTP/2.
2015-04-05 12:01:06 -04:00
if (unlikely((global.mode & MODE_DEBUG) && conn &&
(!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
[MINOR] make use of addr_to_str() and get_host_port() to replace many inet_ntop() Many inet_ntop calls were partially right, which was hard to detect given the complex combinations. Some of them were relying on the listener's proto instead of the address itself, which could have been different when dealing with an accept-proxy connection. The new addr_to_str() function does the dirty job and returns the family, which makes it particularly suited to calls from switch/case statements. A large number of if/else statements were removed and the stats output could even be cleaned up in the case of session dump. As a side effect of doing this, the resulting code is smaller by almost 1kB. All changed parts have been tested and provided expected output.
2011-09-04 18:36:48 -04:00
char pn[INET6_ADDRSTRLEN];
MINOR: frontend: report the connection's ALPN in the debug output Now the incoming connection will also report the ALPN field, truncated to 15 characters.
2016-12-04 13:05:24 -05:00
char alpn[16] = "<none>";
MINOR: frontend: don't retrieve ALPN on the critical path It's pointless to read it on each and every accept(), as we only need it for reporting in debugging mode a few lines later. Let's move this part to the relevant block.
2017-09-15 05:43:32 -04:00
const char *alpn_str = NULL;
int alpn_len;
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MINOR: frontend: don't retrieve ALPN on the critical path It's pointless to read it on each and every accept(), as we only need it for reporting in debugging mode a few lines later. Let's move this part to the relevant block.
2017-09-15 05:43:32 -04:00
/* try to report the ALPN value when available (also works for NPN) */
CLEANUP: stconn: rename cs_conn() to sc_conn() It's mostly used from upper layers. Both the checked and unchecked functions were updated, or ~150 entries.
2022-05-18 10:23:22 -04:00
if (conn == sc_conn(s->scf)) {
MINOR: frontend: don't retrieve ALPN on the critical path It's pointless to read it on each and every accept(), as we only need it for reporting in debugging mode a few lines later. Let's move this part to the relevant block.
2017-09-15 05:43:32 -04:00
if (conn_get_alpn(conn, &alpn_str, &alpn_len) && alpn_str) {
int len = MIN(alpn_len, sizeof(alpn) - 1);
memcpy(alpn, alpn_str, len);
alpn[len] = 0;
}
MINOR: frontend: report the connection's ALPN in the debug output Now the incoming connection will also report the ALPN field, truncated to 15 characters.
2016-12-04 13:05:24 -05:00
}
CLEANUP: stconn: rename cs{,_get}_{src,dst} to sc_* The following functions were renamed: cs_src() -> sc_src() cs_dst() -> sc_dst() cs_get_src() -> sc_get_src() cs_get_dst() -> sc_get_dst()
2022-05-27 02:57:21 -04:00
src = sc_src(s->scf);
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
if (!src) {
MINOR: frontend: switch to conn_get_{src,dst}() for logging and debugging The frontend accept code uses conn_get_{from,to}_addr for logging and debugging, without really checking if the operation succeeds. In preparation of future changes, let's switch to conn_get_{src,dst}() and integrate status check for possible failures.
2019-07-17 05:25:46 -04:00
chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [listener:%d] ALPN=%s\n",
REORG: listener: move the receiving FD to struct receiver The listening socket is represented by its file descriptor, which is generic to all receivers and not just listeners, so it must move to the rx struct. It's worth noting that in order to extend receivers and listeners to other protocols such as QUIC, we'll need other handles than file descriptors here, and that either a union or a cast to uintptr_t will have to be used. This was not done yet and the field was preserved under the name "fd" to avoid adding confusion.
2020-08-27 02:16:52 -04:00
s->uniq_id, fe->id, (unsigned short)l->rx.fd, (unsigned short)conn->handle.fd,
MINOR: frontend: switch to conn_get_{src,dst}() for logging and debugging The frontend accept code uses conn_get_{from,to}_addr for logging and debugging, without really checking if the operation succeeds. In preparation of future changes, let's switch to conn_get_{src,dst}() and integrate status check for possible failures.
2019-07-17 05:25:46 -04:00
l->luid, alpn);
}
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
else switch (addr_to_str(src, pn, sizeof(pn))) {
[MINOR] make use of addr_to_str() and get_host_port() to replace many inet_ntop() Many inet_ntop calls were partially right, which was hard to detect given the complex combinations. Some of them were relying on the listener's proto instead of the address itself, which could have been different when dealing with an accept-proxy connection. The new addr_to_str() function does the dirty job and returns the family, which makes it particularly suited to calls from switch/case statements. A large number of if/else statements were removed and the stats output could even be cleaned up in the case of session dump. As a side effect of doing this, the resulting code is smaller by almost 1kB. All changed parts have been tested and provided expected output.
2011-09-04 18:36:48 -04:00
case AF_INET:
case AF_INET6:
MINOR: frontend: report the connection's ALPN in the debug output Now the incoming connection will also report the ALPN field, truncated to 15 characters.
2016-12-04 13:05:24 -05:00
chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [%s:%d] ALPN=%s\n",
REORG: listener: move the receiving FD to struct receiver The listening socket is represented by its file descriptor, which is generic to all receivers and not just listeners, so it must move to the rx struct. It's worth noting that in order to extend receivers and listeners to other protocols such as QUIC, we'll need other handles than file descriptors here, and that either a union or a cast to uintptr_t will have to be used. This was not done yet and the field was preserved under the name "fd" to avoid adding confusion.
2020-08-27 02:16:52 -04:00
s->uniq_id, fe->id, (unsigned short)l->rx.fd, (unsigned short)conn->handle.fd,
MINOR: frontend: Rely on client src and dst addresses at stream level For now, stream-interface or session addresses are never set. So, thanks to the fallback mechanism, no changes are expected with this patch. But its purpose is to rely on the client addresses at the stream level, when set, instead of those at the connection level. The addresses are retrieved from the frontend stream-interface.
2021-10-22 11:39:06 -04:00
pn, get_host_port(src), alpn);
[MINOR] make use of addr_to_str() and get_host_port() to replace many inet_ntop() Many inet_ntop calls were partially right, which was hard to detect given the complex combinations. Some of them were relying on the listener's proto instead of the address itself, which could have been different when dealing with an accept-proxy connection. The new addr_to_str() function does the dirty job and returns the family, which makes it particularly suited to calls from switch/case statements. A large number of if/else statements were removed and the stats output could even be cleaned up in the case of session dump. As a side effect of doing this, the resulting code is smaller by almost 1kB. All changed parts have been tested and provided expected output.
2011-09-04 18:36:48 -04:00
break;
case AF_UNIX:
MEDIUM: protocol: make abns a custom unix socket address family This is a pre-requisite to adding the abnsz socket address family: in this patch we make use of protocol API rework started by 732913f ("MINOR: protocol: properly assign the sock_domain and sock_family") in order to implement a dedicated address family for ABNS sockets (based on UNIX parent family). Thanks to this, it will become trivial to implement a new ABNSZ (for abns zero) family which is essentially the same as ABNS but with a slight difference when it comes to path handling (ABNS uses the whole sun_path length, while ABNSZ's path is zero terminated and evaluation stops at 0) It was verified that this patch doesn't break reg-tests and behaves properly (tests performed on the CLI with show sess and show fd). Anywhere relevant, AF_CUST_ABNS is handled alongside AF_UNIX. If no distinction needs to be made, real_family() is used to fetch the proper real family type to handle it properly. Both stream and dgram were converted, so no functional change should be expected for this "internal" rework, except that proto will be displayed as "abns_{stream,dgram}" instead of "unix_{stream,dgram}". Before ("show sess" output): 0x64c35528aab0: proto=unix_stream src=unix:1 fe=GLOBAL be=<NONE> srv=<none> ts=00 epoch=0 age=0s calls=1 rate=0 cpu=0 lat=0 rq[f=848000h,i=0,an=00h,ax=] rp[f=80008000h,i=0,an=00h,ax=] scf=[8,0h,fd=21,rex=10s,wex=] scb=[8,1h,fd=-1,rex=,wex=] exp=10s rc=0 c_exp= After: 0x619da7ad74c0: proto=abns_stream src=unix:1 fe=GLOBAL be=<NONE> srv=<none> ts=00 epoch=0 age=0s calls=1 rate=0 cpu=0 lat=0 rq[f=848000h,i=0,an=00h,ax=] rp[f=80008000h,i=0,an=00h,ax=] scf=[8,0h,fd=22,rex=10s,wex=] scb=[8,1h,fd=-1,rex=,wex=] exp=10s rc=0 c_exp= Co-authored-by: Aurelien DARRAGON <adarragon@haproxy.com>
2024-08-09 12:48:14 -04:00
case AF_CUST_ABNS:
MINOR: protocol: create abnsz socket address family For now it's the same as abns. We'll need to modify sock_unix_addrcmp(), and a few other ones to support effective path length when dealing with the \0. Let's check with Tristan's patch for this (upcoming patch). Co-authored-by: Aurelien DARRAGON <adarragon@haproxy.com>
2024-08-09 15:12:23 -04:00
case AF_CUST_ABNSZ:
[MINOR] make use of addr_to_str() and get_host_port() to replace many inet_ntop() Many inet_ntop calls were partially right, which was hard to detect given the complex combinations. Some of them were relying on the listener's proto instead of the address itself, which could have been different when dealing with an accept-proxy connection. The new addr_to_str() function does the dirty job and returns the family, which makes it particularly suited to calls from switch/case statements. A large number of if/else statements were removed and the stats output could even be cleaned up in the case of session dump. As a side effect of doing this, the resulting code is smaller by almost 1kB. All changed parts have been tested and provided expected output.
2011-09-04 18:36:48 -04:00
/* UNIX socket, only the destination is known */
MINOR: frontend: report the connection's ALPN in the debug output Now the incoming connection will also report the ALPN field, truncated to 15 characters.
2016-12-04 13:05:24 -05:00
chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [unix:%d] ALPN=%s\n",
REORG: listener: move the receiving FD to struct receiver The listening socket is represented by its file descriptor, which is generic to all receivers and not just listeners, so it must move to the rx struct. It's worth noting that in order to extend receivers and listeners to other protocols such as QUIC, we'll need other handles than file descriptors here, and that either a union or a cast to uintptr_t will have to be used. This was not done yet and the field was preserved under the name "fd" to avoid adding confusion.
2020-08-27 02:16:52 -04:00
s->uniq_id, fe->id, (unsigned short)l->rx.fd, (unsigned short)conn->handle.fd,
MINOR: frontend: report the connection's ALPN in the debug output Now the incoming connection will also report the ALPN field, truncated to 15 characters.
2016-12-04 13:05:24 -05:00
l->luid, alpn);
[MINOR] make use of addr_to_str() and get_host_port() to replace many inet_ntop() Many inet_ntop calls were partially right, which was hard to detect given the complex combinations. Some of them were relying on the listener's proto instead of the address itself, which could have been different when dealing with an accept-proxy connection. The new addr_to_str() function does the dirty job and returns the family, which makes it particularly suited to calls from switch/case statements. A large number of if/else statements were removed and the stats output could even be cleaned up in the case of session dump. As a side effect of doing this, the resulting code is smaller by almost 1kB. All changed parts have been tested and provided expected output.
2011-09-04 18:36:48 -04:00
break;
[MINOR] Support of unix listener sockets for debug and log event messages on frontend.c
2010-10-22 10:33:18 -04:00
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MINOR: use DISGUISE() everywhere we deliberately want to ignore a result It's more generic and versatile than the previous shut_your_big_mouth_gcc() that was used to silence annoying warnings as it's not limited to ignoring syscalls returns only. This allows us to get rid of the aforementioned function and the shut_your_big_mouth_gcc_int variable, that started to look ugly in multi-threaded environments.
2020-03-14 06:03:20 -04:00
DISGUISE(write(1, trash.area, trash.data));
[MEDIUM] separate protocol-level accept() from the frontend's For a long time we had two large accept() functions, one for TCP sockets instanciating proxies, and another one for UNIX sockets instanciating the stats interface. A lot of code was duplicated and both did not work exactly the same way. Now we have a stream_sock layer accept() called for either TCP or UNIX sockets, and this function calls the frontend-specific accept() function which does the rest of the frontend-specific initialisation. Some code is still duplicated (session & task allocation, stream interface initialization), and might benefit from having an intermediate session-level accept() callback to perform such initializations. Still there are some minor differences that need to be addressed first. For instance, the monitor nets should only be checked for proxies and not for other connection templates. Last, we renamed l->private as l->frontend. The "private" pointer in the listener is only used to store a frontend, so let's rename it to eliminate this ambiguity. When we later support detached listeners (eg: FTP), we'll add another field to avoid the confusion.
2010-05-28 12:46:57 -04:00
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MEDIUM: stream: move the frontend's pointer to the session Just like for the listener, the frontend is session-wide so let's move it to the session. There are a lot of places which were changed but the changes are minimal in fact.
2015-04-03 09:40:56 -04:00
if (fe->mode == PR_MODE_HTTP)
MINOR: stconn/channel: Move CF_READ_DONTWAIT into the SC and rename it The channel flag CF_READ_DONTWAIT is renamed to SC_FL_RCV_ONCE and moved into the stream-connector.
2023-03-16 09:40:03 -04:00
s->scf->flags |= SC_FL_RCV_ONCE; /* one read is usually enough */
[MEDIUM] Collect & provide separate statistics for sockets, v2 This patch allows to collect & provide separate statistics for each socket. It can be very useful if you would like to distinguish between traffic generate by local and remote users or between different types of remote clients (peerings, domestic, foreign). Currently no "Session rate" is supported, but adding it should be possible if we found it useful.
2009-10-04 09:43:17 -04:00
MINOR: frontend: initialize HTTP layer after the debugging code For HTTP/2 we'll have to choose the upper layer based on the advertised protocol name here and we want to keep debugging, so let's move debugging earlier.
2016-12-04 12:39:22 -05:00
if (unlikely(fe->nb_req_cap > 0)) {
CLEANUP: frontend: use pool_zalloc() in frontend_accept() The capture buffers were allocated then zeroed, let's have the allocator do it.
2021-03-22 16:06:21 -04:00
if ((s->req_cap = pool_zalloc(fe->req_cap_pool)) == NULL)
MINOR: frontend: initialize HTTP layer after the debugging code For HTTP/2 we'll have to choose the upper layer based on the advertised protocol name here and we want to keep debugging, so let's move debugging earlier.
2016-12-04 12:39:22 -05:00
goto out_return; /* no memory */
}
if (unlikely(fe->nb_rsp_cap > 0)) {
CLEANUP: frontend: use pool_zalloc() in frontend_accept() The capture buffers were allocated then zeroed, let's have the allocator do it.
2021-03-22 16:06:21 -04:00
if ((s->res_cap = pool_zalloc(fe->rsp_cap_pool)) == NULL)
MINOR: frontend: initialize HTTP layer after the debugging code For HTTP/2 we'll have to choose the upper layer based on the advertised protocol name here and we want to keep debugging, so let's move debugging earlier.
2016-12-04 12:39:22 -05:00
goto out_free_reqcap; /* no memory */
}
MINOR: http-ana: Simplify creation/destruction of HTTP transactions Now allocation and initialization of HTTP transactions are performed in a unique function. Historically, there were two functions because the same TXN was reset for K/A connections in the legacy HTTP mode. Now, in HTX, K/A connections are handled at the mux level. A new stream, and thus a new TXN, is created for each request. In addition, the function responsible to end the TXN is now also reponsible to release it. So, now, http_create_txn() and http_destroy_txn() must be used to create and destroy an HTTP transaction.
2021-03-08 13:12:58 -05:00
if ((fe->http_needed || IS_HTX_STRM(s)) && !http_create_txn(s))
goto out_free_rspcap;
MINOR: frontend: initialize HTTP layer after the debugging code For HTTP/2 we'll have to choose the upper layer based on the advertised protocol name here and we want to keep debugging, so let's move debugging earlier.
2016-12-04 12:39:22 -05:00
[MAJOR] frontend: split accept() into frontend_accept() and session_accept() A new function session_accept() is now called from the lower layer to instanciate a new session. Once the session is instanciated, the upper layer's frontent_accept() is called. This one can be service-dependant. That way, we have a 3-phase accept() sequence : 1) protocol-specific, session-less accept(), which is pointed to by the listener. It defaults to the generic stream_sock_accept(). 2) session_accept() which relies on a frontend but not necessarily for use in a proxy (eg: stats or any future service). 3) frontend_accept() which performs the accept for the service offerred by the frontend. It defaults to frontend_accept() which is really what is used by a proxy. The TCP/HTTP proxies have been moved to this mode so that we can now rely on frontend_accept() for any type of session initialization relying on a frontend. The next step will be to convert the stats to use the same system for the stats.
2010-06-01 11:45:26 -04:00
/* everything's OK, let's go on */
[MEDIUM] separate protocol-level accept() from the frontend's For a long time we had two large accept() functions, one for TCP sockets instanciating proxies, and another one for UNIX sockets instanciating the stats interface. A lot of code was duplicated and both did not work exactly the same way. Now we have a stream_sock layer accept() called for either TCP or UNIX sockets, and this function calls the frontend-specific accept() function which does the rest of the frontend-specific initialisation. Some code is still duplicated (session & task allocation, stream interface initialization), and might benefit from having an intermediate session-level accept() callback to perform such initializations. Still there are some minor differences that need to be addressed first. For instance, the monitor nets should only be checked for proxies and not for other connection templates. Last, we renamed l->private as l->frontend. The "private" pointer in the listener is only used to store a frontend, so let's rename it to eliminate this ambiguity. When we later support detached listeners (eg: FTP), we'll add another field to avoid the confusion.
2010-05-28 12:46:57 -04:00
return 1;
[MEDIUM] simplify error path in event_accept() The error path in event_accept() was complicated by many code duplications. Use the classical unrolling with the gotos. This fix alone reduced the code by 2.5 kB.
2007-11-04 11:51:50 -05:00
/* Error unrolling */
[MAJOR] frontend: reorder the session initialization upon accept This will be needed for the last factoring step which adds support for application-level accept(). The tcp/http accept() code has now been isolated and will have to move to a separate function.
2010-06-01 11:12:40 -04:00
out_free_rspcap:
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(fe->rsp_cap_pool, s->res_cap);
[MAJOR] frontend: reorder the session initialization upon accept This will be needed for the last factoring step which adds support for application-level accept(). The tcp/http accept() code has now been isolated and will have to move to a separate function.
2010-06-01 11:12:40 -04:00
out_free_reqcap:
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(fe->req_cap_pool, s->req_cap);
[BUG] accept: don't close twice upon error The stream_sock's accept() used to close the FD upon error, but this was also sometimes performed by the frontend's accept() called via the session's accept(). Those interlaced calls were also responsible for the spaghetti-looking error unrolling code in session.c and stream_sock.c. Now the frontend must not close the FD anymore, the session is responsible for that. It also takes care of just closing the FD or also removing from the FD lists, depending on its state. The socket-level accept() does not have to care about that anymore.
2010-11-11 04:56:04 -05:00
out_return:
[MEDIUM] separate protocol-level accept() from the frontend's For a long time we had two large accept() functions, one for TCP sockets instanciating proxies, and another one for UNIX sockets instanciating the stats interface. A lot of code was duplicated and both did not work exactly the same way. Now we have a stream_sock layer accept() called for either TCP or UNIX sockets, and this function calls the frontend-specific accept() function which does the rest of the frontend-specific initialisation. Some code is still duplicated (session & task allocation, stream interface initialization), and might benefit from having an intermediate session-level accept() callback to perform such initializations. Still there are some minor differences that need to be addressed first. For instance, the monitor nets should only be checked for proxies and not for other connection templates. Last, we renamed l->private as l->frontend. The "private" pointer in the listener is only used to store a frontend, so let's rename it to eliminate this ambiguity. When we later support detached listeners (eg: FTP), we'll add another field to avoid the confusion.
2010-05-28 12:46:57 -04:00
return -1;
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
}
MINOR: frontend: implement a dedicated actconn increment function When a new frontend connection is instantiated, actconn global counter is incremented. If global maxconn value is reached, the connection is cancelled. This ensures that system limit are under control. Prior to this patch, the atomic check/increment operations were done directly into listener_accept(). Move them in a dedicated function increment_actconn() in frontend module. This will be useful when QUIC connections will be counted in actconn counter.
2023-10-25 09:32:28 -04:00
/* Increment current active connection counter. This ensures that global
* maxconn is not reached or exceeded. This must be done for every new frontend
* connection allocation.
*
* Returns the new actconn global value. If maxconn reached or exceeded, 0 is
* returned : the connection allocation should be cancelled.
*/
int increment_actconn()
{
unsigned int count, next_actconn;
do {
count = actconn;
if (unlikely(count >= global.maxconn)) {
/* maxconn reached */
next_actconn = 0;
goto end;
}
/* try to increment actconn */
next_actconn = count + 1;
} while (!_HA_ATOMIC_CAS(&actconn, (int *)(&count), next_actconn) && __ha_cpu_relax());
end:
return next_actconn;
}
MINOR: frontend: rename sample fetch functions and declare the sample keywords The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : fe_conn, fe_id, fe_sess_rate The fetch functions have been renamed "smp_fetch_*".
2013-01-07 16:48:29 -05:00
/************************************************************************/
/* All supported sample and ACL keywords must be declared here. */
/************************************************************************/
MEDIUM: acl: use temp_pattern to store any integer-type information All ACL fetches which return integer value now store the result into the temporary pattern struct. All ACL matches which rely on integer also get their value there. Note: the pattern data types are not set right now.
2011-12-16 11:06:15 -05:00
/* set temp integer to the id of the frontend */
[MINOR] acl: specify the direction during fetches Some fetches such as 'line' or 'hdr' need to know the direction of the test (request or response). A new 'dir' parameter is now propagated from the caller to achieve this.
2007-06-10 04:06:18 -04:00
static int
MEDIUM: sample: change the prototype of sample-fetches functions This patch removes the "opt" entry from the prototype of the sample-fetches fucntions. This permits to remove some weight in the prototype call.
2015-05-11 09:42:45 -04:00
smp_fetch_fe_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
MAJOR: acl: make use of the new sample struct and get rid of acl_test This change is invasive in lines of code but not much in terms of functionalities as it's mainly a replacement of struct acl_test with struct sample.
2012-04-23 10:16:37 -04:00
{
MEDIUM: pattern/acl: get rid of temp_pattern in ACLs This one is not needed anymore as we can return the data and its type in the sample provided by the caller. ACLs now always return the proper type. BOOL is already returned when the result is expected to be processed as a boolean. temp_pattern has been unexported now.
2012-04-23 12:53:56 -04:00
smp->flags = SMP_F_VOL_SESS;
MEDIUM: samples: Use the "struct sample_data" in the "struct sample" This patch remove the struct information stored both in the struct sample_data and in the striuct sample. Now, only thestruct sample_data contains data, and the struct sample use the struct sample_data for storing his own data.
2015-08-19 03:00:18 -04:00
smp->data.type = SMP_T_SINT;
MINOR: samples: rename union from "data" to "u" The union name "data" is a little bit heavy while we read the source code because we can read "data.data.sint". The rename from "data" to "u" makes the read easiest like "data.u.sint".
2015-08-19 03:07:19 -04:00
smp->data.u.sint = smp->sess->fe->uuid;
[MEDIUM] Add src dst and dport pattern fetches.
2010-01-04 09:47:45 -05:00
return 1;
}
MINOR: proxy: Add fe_name/be_name fetchers next to existing fe_id/be_id These 2 patches add ability to fetch frontend/backend name in your logic, so they can be used later to make routing decisions (fe_name) or taking some actions based on backend which responded to request (be_name). In our case we needed a fetcher to be able to extract information we needed from frontend name.
2016-12-12 08:08:05 -05:00
/* set string to the name of the frontend */
static int
smp_fetch_fe_name(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
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
smp->data.u.str.area = (char *)smp->sess->fe->id;
if (!smp->data.u.str.area)
MINOR: proxy: Add fe_name/be_name fetchers next to existing fe_id/be_id These 2 patches add ability to fetch frontend/backend name in your logic, so they can be used later to make routing decisions (fe_name) or taking some actions based on backend which responded to request (be_name). In our case we needed a fetcher to be able to extract information we needed from frontend name.
2016-12-12 08:08:05 -05:00
return 0;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
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
smp->data.u.str.data = strlen(smp->data.u.str.area);
MINOR: proxy: Add fe_name/be_name fetchers next to existing fe_id/be_id These 2 patches add ability to fetch frontend/backend name in your logic, so they can be used later to make routing decisions (fe_name) or taking some actions based on backend which responded to request (be_name). In our case we needed a fetcher to be able to extract information we needed from frontend name.
2016-12-12 08:08:05 -05:00
return 1;
}
MINOR: proxy: Add fe_defbe fetcher Patch adds ability to fetch frontend's default backend name in your logic, so it can be used later to derive other backend names to make routing decisions.
2018-04-13 08:37:50 -04:00
/* set string to the name of the default backend */
static int
smp_fetch_fe_defbe(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
if (!smp->sess->fe->defbe.be)
return 0;
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
smp->data.u.str.area = (char *)smp->sess->fe->defbe.be->id;
if (!smp->data.u.str.area)
MINOR: proxy: Add fe_defbe fetcher Patch adds ability to fetch frontend's default backend name in your logic, so it can be used later to derive other backend names to make routing decisions.
2018-04-13 08:37:50 -04:00
return 0;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
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
smp->data.u.str.data = strlen(smp->data.u.str.area);
MINOR: proxy: Add fe_defbe fetcher Patch adds ability to fetch frontend's default backend name in your logic, so it can be used later to derive other backend names to make routing decisions.
2018-04-13 08:37:50 -04:00
return 1;
}
MINOR: Add fe_req_rate sample fetch The fe_req_rate is similar to fe_sess_rate, but fetches the number of HTTP requests per second instead of connections/sessions per second. Signed-off-by: Nenad Merdanovic <nmerdan@anine.io>
2016-10-02 22:57:37 -04:00
/* set temp integer to the number of HTTP requests per second reaching the frontend.
* Accepts exactly 1 argument. Argument is a frontend, other types will cause
* an undefined behaviour.
*/
static int
smp_fetch_fe_req_rate(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
MINOR: sample/arg: Be able to resolve args found in defaults sections It is not yet used but thanks to this patch, it will be possible to resolve arguments found in defaults sections. However, there is some restrictions: * For FE (frontend) or BE (backend) arguments, if the proxy is explicity defined, there is no change. But for implicit proxy (not specified), the argument points on the default proxy. when a sample fetch using this kind of argument is evaluated, the default proxy replaced by the current one. * For SRV (server) and TAB (stick-table)arguments, the proxy must always be specified. Otherwise an error is reported. This patch is mandatory to support TCP/HTTP rules in defaults sections.
2021-10-12 12:48:05 -04:00
struct proxy *px = args->data.prx;
if (px == NULL)
return 0;
if (px->cap & PR_CAP_DEF)
px = smp->px;
MINOR: Add fe_req_rate sample fetch The fe_req_rate is similar to fe_sess_rate, but fetches the number of HTTP requests per second instead of connections/sessions per second. Signed-off-by: Nenad Merdanovic <nmerdan@anine.io>
2016-10-02 22:57:37 -04:00
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
MEDIUM: stats: avoid 1 indirection by storing the shared stats directly in counters struct Between 3.2 and 3.3-dev we noticed a noticeable performance regression due to stats handling. After bisecting, Willy found out that recent work to split stats computing accross multiple thread groups (stats sharding) was responsible for that performance regression. We're looking at roughly 20% performance loss. More precisely, it is the added indirections, multiplied by the number of statistics that are updated for each request, which in the end causes a significant amount of time being spent resolving pointers. We noticed that the fe_counters_shared and be_counters_shared structures which are currently allocated in dedicated memory since a0dcab5c ("MAJOR: counters: add shared counters base infrastructure") are no longer huge since 16eb0fab31 ("MAJOR: counters: dispatch counters over thread groups") because they now essentially hold flags plus the per-thread group id pointer mapping, not the counters themselves. As such we decided to try merging fe_counters_shared and be_counters_shared in their parent structures. The cost is slight memory overhead for the parent structure, but it allows to get rid of one pointer indirection. This patch alone yields visible performance gains and almost restores 3.2 stats performance. counters_fe_shared_get() was renamed to counters_fe_shared_prepare() and now returns either failure or success instead of a pointer because we don't need to retrieve a shared pointer anymore, the function takes care of initializing existing pointer.
2025-07-22 11:15:02 -04:00
smp->data.u.sint = COUNTERS_SHARED_TOTAL(px->fe_counters.shared.tg, req_per_sec, read_freq_ctr);
MINOR: Add fe_req_rate sample fetch The fe_req_rate is similar to fe_sess_rate, but fetches the number of HTTP requests per second instead of connections/sessions per second. Signed-off-by: Nenad Merdanovic <nmerdan@anine.io>
2016-10-02 22:57:37 -04:00
return 1;
}
MAJOR: acl: make use of the new argument parsing framework The ACL parser now uses the argument parser to build a typed argument list. Right now arguments are all strings and only one argument is supported since this is what ACLs currently support.
2012-04-19 11:16:54 -04:00
/* set temp integer to the number of connections per second reaching the frontend.
MEDIUM: acl: remove unused tests for missing args when args are mandatory A number of ACL fetch methods use mandatory arguments (eg: proxy names) so it's pointless to test for the presence of this argument now.
2012-04-20 05:37:56 -04:00
* Accepts exactly 1 argument. Argument is a frontend, other types will cause
MAJOR: acl: make use of the new argument parsing framework The ACL parser now uses the argument parser to build a typed argument list. Right now arguments are all strings and only one argument is supported since this is what ACLs currently support.
2012-04-19 11:16:54 -04:00
* an undefined behaviour.
*/
[MINOR] acl: specify the direction during fetches Some fetches such as 'line' or 'hdr' need to know the direction of the test (request or response). A new 'dir' parameter is now propagated from the caller to achieve this.
2007-06-10 04:06:18 -04:00
static int
MEDIUM: sample: change the prototype of sample-fetches functions This patch removes the "opt" entry from the prototype of the sample-fetches fucntions. This permits to remove some weight in the prototype call.
2015-05-11 09:42:45 -04:00
smp_fetch_fe_sess_rate(const struct arg *args, struct sample *smp, const char *kw, void *private)
[MINOR] implement the ACL keywords 'dst' and 'dport' The file client.c now provides acl_fetch_dip and acl_fetch_dport to be able to check the client's destination address and port. The corresponding ACL keywords 'dst' and 'dport' have been added.
2007-05-08 13:56:15 -04:00
{
MINOR: sample/arg: Be able to resolve args found in defaults sections It is not yet used but thanks to this patch, it will be possible to resolve arguments found in defaults sections. However, there is some restrictions: * For FE (frontend) or BE (backend) arguments, if the proxy is explicity defined, there is no change. But for implicit proxy (not specified), the argument points on the default proxy. when a sample fetch using this kind of argument is evaluated, the default proxy replaced by the current one. * For SRV (server) and TAB (stick-table)arguments, the proxy must always be specified. Otherwise an error is reported. This patch is mandatory to support TCP/HTTP rules in defaults sections.
2021-10-12 12:48:05 -04:00
struct proxy *px = args->data.prx;
if (px == NULL)
return 0;
if (px->cap & PR_CAP_DEF)
px = smp->px;
MAJOR: acl: make use of the new sample struct and get rid of acl_test This change is invasive in lines of code but not much in terms of functionalities as it's mainly a replacement of struct acl_test with struct sample.
2012-04-23 10:16:37 -04:00
smp->flags = SMP_F_VOL_TEST;
MEDIUM: samples: Use the "struct sample_data" in the "struct sample" This patch remove the struct information stored both in the struct sample_data and in the striuct sample. Now, only thestruct sample_data contains data, and the struct sample use the struct sample_data for storing his own data.
2015-08-19 03:00:18 -04:00
smp->data.type = SMP_T_SINT;
MEDIUM: stats: avoid 1 indirection by storing the shared stats directly in counters struct Between 3.2 and 3.3-dev we noticed a noticeable performance regression due to stats handling. After bisecting, Willy found out that recent work to split stats computing accross multiple thread groups (stats sharding) was responsible for that performance regression. We're looking at roughly 20% performance loss. More precisely, it is the added indirections, multiplied by the number of statistics that are updated for each request, which in the end causes a significant amount of time being spent resolving pointers. We noticed that the fe_counters_shared and be_counters_shared structures which are currently allocated in dedicated memory since a0dcab5c ("MAJOR: counters: add shared counters base infrastructure") are no longer huge since 16eb0fab31 ("MAJOR: counters: dispatch counters over thread groups") because they now essentially hold flags plus the per-thread group id pointer mapping, not the counters themselves. As such we decided to try merging fe_counters_shared and be_counters_shared in their parent structures. The cost is slight memory overhead for the parent structure, but it allows to get rid of one pointer indirection. This patch alone yields visible performance gains and almost restores 3.2 stats performance. counters_fe_shared_get() was renamed to counters_fe_shared_prepare() and now returns either failure or success instead of a pointer because we don't need to retrieve a shared pointer anymore, the function takes care of initializing existing pointer.
2025-07-22 11:15:02 -04:00
smp->data.u.sint = COUNTERS_SHARED_TOTAL(px->fe_counters.shared.tg, sess_per_sec, read_freq_ctr);
[MEDIUM] Add src dst and dport pattern fetches.
2010-01-04 09:47:45 -05:00
return 1;
}
[MEDIUM] New option http_proxy Hello, You will find attached an updated release of previously submitted patch. It polish some part and extend ACL engine to match IP and PORT parsed in HTTP request. (and take care of comments made by Willy ! ;)) Best regards, Alexandre
2007-11-29 09:43:32 -05:00
MAJOR: acl: make use of the new argument parsing framework The ACL parser now uses the argument parser to build a typed argument list. Right now arguments are all strings and only one argument is supported since this is what ACLs currently support.
2012-04-19 11:16:54 -04:00
/* set temp integer to the number of concurrent connections on the frontend
MEDIUM: acl: remove unused tests for missing args when args are mandatory A number of ACL fetch methods use mandatory arguments (eg: proxy names) so it's pointless to test for the presence of this argument now.
2012-04-20 05:37:56 -04:00
* Accepts exactly 1 argument. Argument is a frontend, other types will cause
MAJOR: acl: make use of the new argument parsing framework The ACL parser now uses the argument parser to build a typed argument list. Right now arguments are all strings and only one argument is supported since this is what ACLs currently support.
2012-04-19 11:16:54 -04:00
* an undefined behaviour.
*/
[MINOR] acl: specify the direction during fetches Some fetches such as 'line' or 'hdr' need to know the direction of the test (request or response). A new 'dir' parameter is now propagated from the caller to achieve this.
2007-06-10 04:06:18 -04:00
static int
MEDIUM: sample: change the prototype of sample-fetches functions This patch removes the "opt" entry from the prototype of the sample-fetches fucntions. This permits to remove some weight in the prototype call.
2015-05-11 09:42:45 -04:00
smp_fetch_fe_conn(const struct arg *args, struct sample *smp, const char *kw, void *private)
[MEDIUM] added several ACL criteria and matches Many ACL criteria have been added. Some others are still commented out because some functions are still missing.
2007-05-06 18:55:35 -04:00
{
MINOR: sample/arg: Be able to resolve args found in defaults sections It is not yet used but thanks to this patch, it will be possible to resolve arguments found in defaults sections. However, there is some restrictions: * For FE (frontend) or BE (backend) arguments, if the proxy is explicity defined, there is no change. But for implicit proxy (not specified), the argument points on the default proxy. when a sample fetch using this kind of argument is evaluated, the default proxy replaced by the current one. * For SRV (server) and TAB (stick-table)arguments, the proxy must always be specified. Otherwise an error is reported. This patch is mandatory to support TCP/HTTP rules in defaults sections.
2021-10-12 12:48:05 -04:00
struct proxy *px = args->data.prx;
if (px == NULL)
return 0;
if (px->cap & PR_CAP_DEF)
px = smp->px;
MAJOR: acl: make use of the new sample struct and get rid of acl_test This change is invasive in lines of code but not much in terms of functionalities as it's mainly a replacement of struct acl_test with struct sample.
2012-04-23 10:16:37 -04:00
smp->flags = SMP_F_VOL_TEST;
MEDIUM: samples: Use the "struct sample_data" in the "struct sample" This patch remove the struct information stored both in the struct sample_data and in the striuct sample. Now, only thestruct sample_data contains data, and the struct sample use the struct sample_data for storing his own data.
2015-08-19 03:00:18 -04:00
smp->data.type = SMP_T_SINT;
MINOR: sample/arg: Be able to resolve args found in defaults sections It is not yet used but thanks to this patch, it will be possible to resolve arguments found in defaults sections. However, there is some restrictions: * For FE (frontend) or BE (backend) arguments, if the proxy is explicity defined, there is no change. But for implicit proxy (not specified), the argument points on the default proxy. when a sample fetch using this kind of argument is evaluated, the default proxy replaced by the current one. * For SRV (server) and TAB (stick-table)arguments, the proxy must always be specified. Otherwise an error is reported. This patch is mandatory to support TCP/HTTP rules in defaults sections.
2021-10-12 12:48:05 -04:00
smp->data.u.sint = px->feconn;
[MINOR] acl: add fe_id/so_id to match frontend's and socket's id
2010-01-12 15:59:30 -05:00
return 1;
}
MINOR: frontend: add client timeout sample fetch Add a sample fetch named fe_client_timeout to return the configuration value for the client timeout on a frontend.
2020-12-10 07:43:55 -05:00
static int
smp_fetch_fe_client_timeout(const struct arg *args, struct sample *smp, const char *km, void *private)
{
smp->flags = SMP_F_VOL_TXN;
smp->data.type = SMP_T_SINT;
smp->data.u.sint = TICKS_TO_MS(smp->sess->fe->timeout.client);
return 1;
}
MEDIUM: Add connect/queue/tarpit timeouts to set-timeout Add the ability to set connect, queue and tarpit timeouts from the set-timeout action. This is especially useful when using set-dst to dynamically connect to servers. This patch also adds the relevant fe_/be_/cur_ sample fetches for these timeouts.
2026-02-18 09:56:36 -05:00
static int
smp_fetch_fe_tarpit_timeout(const struct arg *args, struct sample *smp, const char *km, void *private)
{
smp->flags = SMP_F_VOL_TXN;
smp->data.type = SMP_T_SINT;
smp->data.u.sint = TICKS_TO_MS(smp->sess->fe->timeout.tarpit);
return 1;
}
[MEDIUM] added several ACL criteria and matches Many ACL criteria have been added. Some others are still commented out because some functions are still missing.
2007-05-06 18:55:35 -04:00
MINOR: frontend: rename sample fetch functions and declare the sample keywords The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : fe_conn, fe_id, fe_sess_rate The fetch functions have been renamed "smp_fetch_*".
2013-01-07 16:48:29 -05:00
/* Note: must not be declared <const> as its list will be overwritten.
* Please take care of keeping this list alphabetically sorted.
*/
BUG/MEDIUM: prevent gcc from moving empty keywords lists into BSS Benoit Dolez reported a failure to start haproxy 1.5-dev19. The process would immediately report an internal error with missing fetches from some crap instead of ACL names. The cause is that some versions of gcc seem to trim static structs containing a variable array when moving them to BSS, and only keep the fixed size, which is just a list head for all ACL and sample fetch keywords. This was confirmed at least with gcc 3.4.6. And we can't move these structs to const because they contain a list element which is needed to link all of them together during the parsing. The bug indeed appeared with 1.5-dev19 because it's the first one to have some empty ACL keyword lists. One solution is to impose -fno-zero-initialized-in-bss to everyone but this is not really nice. Another solution consists in ensuring the struct is never empty so that it does not move there. The easy solution consists in having a non-null list head since it's not yet initialized. A new "ILH" list head type was thus created for this purpose : create an Initialized List Head so that gcc cannot move the struct to BSS. This fixes the issue for this version of gcc and does not create any burden for the declarations.
2013-06-21 17:16:39 -04:00
static struct sample_fetch_kw_list smp_kws = {ILH, {
MINOR: frontend: add client timeout sample fetch Add a sample fetch named fe_client_timeout to return the configuration value for the client timeout on a frontend.
2020-12-10 07:43:55 -05:00
{ "fe_client_timeout", smp_fetch_fe_client_timeout, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
MEDIUM: Add connect/queue/tarpit timeouts to set-timeout Add the ability to set connect, queue and tarpit timeouts from the set-timeout action. This is especially useful when using set-dst to dynamically connect to servers. This patch also adds the relevant fe_/be_/cur_ sample fetches for these timeouts.
2026-02-18 09:56:36 -05:00
{ "fe_tarpit_timeout", smp_fetch_fe_tarpit_timeout, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
MINOR: frontend: add client timeout sample fetch Add a sample fetch named fe_client_timeout to return the configuration value for the client timeout on a frontend.
2020-12-10 07:43:55 -05:00
{ "fe_conn", smp_fetch_fe_conn, ARG1(1,FE), NULL, SMP_T_SINT, SMP_USE_INTRN, },
{ "fe_defbe", smp_fetch_fe_defbe, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
{ "fe_id", smp_fetch_fe_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
{ "fe_name", smp_fetch_fe_name, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
{ "fe_req_rate", smp_fetch_fe_req_rate, ARG1(1,FE), NULL, SMP_T_SINT, SMP_USE_INTRN, },
{ "fe_sess_rate", smp_fetch_fe_sess_rate, ARG1(1,FE), NULL, SMP_T_SINT, SMP_USE_INTRN, },
MINOR: frontend: rename sample fetch functions and declare the sample keywords The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : fe_conn, fe_id, fe_sess_rate The fetch functions have been renamed "smp_fetch_*".
2013-01-07 16:48:29 -05:00
{ /* END */ },
}};
MEDIUM: init: convert all trivial registration calls to initcalls This switches explicit calls to various trivial registration methods for keywords, muxes or protocols from constructors to INITCALL1 at stage STG_REGISTER. All these calls have in common to consume a single pointer and return void. Doing this removes 26 constructors. The following calls were addressed : - acl_register_keywords - bind_register_keywords - cfg_register_keywords - cli_register_kw - flt_register_keywords - http_req_keywords_register - http_res_keywords_register - protocol_register - register_mux_proto - sample_register_convs - sample_register_fetches - srv_register_keywords - tcp_req_conn_keywords_register - tcp_req_cont_keywords_register - tcp_req_sess_keywords_register - tcp_res_cont_keywords_register - flt_register_keywords
2018-11-25 13:14:37 -05:00
INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
MINOR: frontend: rename sample fetch functions and declare the sample keywords The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : fe_conn, fe_id, fe_sess_rate The fetch functions have been renamed "smp_fetch_*".
2013-01-07 16:48:29 -05:00
MAJOR: acl: store the ACL argument types in the ACL keyword declaration The types and minimal number of ACL keyword arguments are now stored in their declaration. This will allow many more fantasies if some ACL use several arguments or types. Doing so required to rework all ACL keyword declarations to add two parameters. So this was a good opportunity for a general cleanup and to sort all entries in alphabetical order. We still have two pending issues : - parse_acl_expr() checks for errors but has no way to report them to the user ; - the types of some arguments are still not resolved and kept as strings (eg: ARGT_FE/BE/TAB) for compatibility reasons, which must be resolved in acl_find_targets()
2012-04-19 12:42:05 -04:00
/* Note: must not be declared <const> as its list will be overwritten.
* Please take care of keeping this list alphabetically sorted.
*/
BUG/MEDIUM: prevent gcc from moving empty keywords lists into BSS Benoit Dolez reported a failure to start haproxy 1.5-dev19. The process would immediately report an internal error with missing fetches from some crap instead of ACL names. The cause is that some versions of gcc seem to trim static structs containing a variable array when moving them to BSS, and only keep the fixed size, which is just a list head for all ACL and sample fetch keywords. This was confirmed at least with gcc 3.4.6. And we can't move these structs to const because they contain a list element which is needed to link all of them together during the parsing. The bug indeed appeared with 1.5-dev19 because it's the first one to have some empty ACL keyword lists. One solution is to impose -fno-zero-initialized-in-bss to everyone but this is not really nice. Another solution consists in ensuring the struct is never empty so that it does not move there. The easy solution consists in having a non-null list head since it's not yet initialized. A new "ILH" list head type was thus created for this purpose : create an Initialized List Head so that gcc cannot move the struct to BSS. This fixes the issue for this version of gcc and does not create any burden for the declarations.
2013-06-21 17:16:39 -04:00
static struct acl_kw_list acl_kws = {ILH, {
MINOR: frontend: rename sample fetch functions and declare the sample keywords The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : fe_conn, fe_id, fe_sess_rate The fetch functions have been renamed "smp_fetch_*".
2013-01-07 16:48:29 -05:00
{ /* END */ },
[MEDIUM] added several ACL criteria and matches Many ACL criteria have been added. Some others are still commented out because some functions are still missing.
2007-05-06 18:55:35 -04:00
}};
MEDIUM: init: convert all trivial registration calls to initcalls This switches explicit calls to various trivial registration methods for keywords, muxes or protocols from constructors to INITCALL1 at stage STG_REGISTER. All these calls have in common to consume a single pointer and return void. Doing this removes 26 constructors. The following calls were addressed : - acl_register_keywords - bind_register_keywords - cfg_register_keywords - cli_register_kw - flt_register_keywords - http_req_keywords_register - http_res_keywords_register - protocol_register - register_mux_proto - sample_register_convs - sample_register_fetches - srv_register_keywords - tcp_req_conn_keywords_register - tcp_req_cont_keywords_register - tcp_req_sess_keywords_register - tcp_res_cont_keywords_register - flt_register_keywords
2018-11-25 13:14:37 -05:00
INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
[MEDIUM] added several ACL criteria and matches Many ACL criteria have been added. Some others are still commented out because some functions are still missing.
2007-05-06 18:55:35 -04:00
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink