RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-02-26 15:40:32 +00:00
Code Issues Packages Projects Releases Wiki Activity
fbc74e8556
haproxy/src/frontend.c

272 lines
7.9 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-26 00:48:02 +00: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 19:02:37 +00: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-26 00:48:02 +00: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 21:48:29 +00: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-26 00:48:02 +00: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 <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 15:53:05 +00: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-26 00:48:02 +00: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 14:26:39 +00:00
#include <netinet/tcp.h>
REORG: buffers: split buffers into chunk,buffer,channel Many parts of the channel definition still make use of the "buffer" word.
2012-08-24 17:22:53 +00:00
#include <common/chunk.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 15:53:05 +00:00
#include <common/compat.h>
[CLEANUP] included common/version.h everywhere
2006-06-29 16:54:54 +00:00
#include <common/config.h>
[MINOR] frontend: add a new analyser to parse a proxied connection The introduction of a new PROXY protocol for proxied connections requires an early analyser to decode the incoming connection and set the session flags accordingly. Some more work is needed, among which setting a flag on the session to indicate it's proxied, and copying the original parameters for later comparisons with new ACLs (eg: real_src, ...).
2010-10-15 21:23:19 +00:00
#include <common/debug.h>
#include <common/standard.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 15:53:05 +00:00
#include <common/time.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-26 00:48:02 +00:00
#include <types/global.h>
[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 22:55:35 +00:00
#include <proto/acl.h>
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 16:42:05 +00:00
#include <proto/arg.h>
REORG: buffers: split buffers into chunk,buffer,channel Many parts of the channel definition still make use of the "buffer" word.
2012-08-24 17:22:53 +00:00
#include <proto/channel.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-26 00:48:02 +00:00
#include <proto/fd.h>
[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 19:02:37 +00:00
#include <proto/frontend.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-26 00:48:02 +00:00
#include <proto/log.h>
[MEDIUM] added the hdr_idx structure for future HTTP header indexing This structure will consume 4 bytes per header to keep track of headers within a request or a response without having to parse the whole request for each regex. As it's not possible to allocate only 4 bytes, we define a max number of HTTP headers. We set it to (BUFSIZE+79)/80 so that 8kB buffers can contain 100 headers (like Apache), resulting in 400 bytes dedicated to indexation, or about 400/(2*8kB) ~= 2.4% of the memory usage.
2006-12-03 14:21:35 +00:00
#include <proto/hdr_idx.h>
[MEDIUM] move connection establishment from backend to the SI. The connection establishment was completely handled by backend.c which normally just handles LB algos. Since it's purely TCP, it must move to proto_tcp.c. Also, instead of calling it directly, we now call it via the stream interface, which will later help us unify session handling.
2009-08-16 12:02:45 +00:00
#include <proto/proto_tcp.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-26 00:48:02 +00:00
#include <proto/proto_http.h>
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
#include <proto/proxy.h>
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 21:48:29 +00:00
#include <proto/sample.h>
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 22:22:06 +00:00
#include <proto/stream.h>
[MINOR] replace client_retnclose() with stream_int_retnclose() This makes more sense to return a message to a stream interface than to a session. senddata.{c,h} have been removed.
2008-11-30 18:48:07 +00:00
#include <proto/stream_interface.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-26 00:48:02 +00:00
#include <proto/task.h>
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 22:22:06 +00: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 09:56:04 +00: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 16:01:06 +00: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-26 00:48:02 +00: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 22:22:06 +00: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 16:46:57 +00: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 13:40:56 +00: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 16:01:06 +00: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 13:40:56 +00: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 12:46:27 +00: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 13:40:56 +00:00
if ((fe->mode == PR_MODE_TCP || fe->mode == PR_MODE_HTTP)
&& (!LIST_ISEMPTY(&fe->logsrvs))) {
if (likely(!LIST_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 16:46:57 +00: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 08:40:16 +00:00
if (!(s->logs.logwait &= ~(LW_CLIP|LW_INIT)))
[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 16:46:57 +00:00
s->do_log(s);
[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 21:52:51 +00: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 16:01:06 +00:00
else if (conn) {
[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 16:46:57 +00:00
char pn[INET6_ADDRSTRLEN], sn[INET6_ADDRSTRLEN];
[MEDIUM] store the original destination address in the session There are multiple places where the client's destination address is required. Let's store it in the session when needed, and add a flag to inform that it has been retrieved.
2007-05-08 17:46:30 +00:00
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 08:45:07 +00:00
conn_get_from_addr(conn);
conn_get_to_addr(conn);
[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-26 00:48:02 +00:00
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 08:45:07 +00:00
switch (addr_to_str(&conn->addr.from, 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 22:36:48 +00:00
case AF_INET:
case AF_INET6:
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 08:45:07 +00:00
addr_to_str(&conn->addr.to, sn, sizeof(sn));
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 13:40:56 +00:00
send_log(fe, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 08:45:07 +00:00
pn, get_host_port(&conn->addr.from),
sn, get_host_port(&conn->addr.to),
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 13:40:56 +00:00
fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
[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 22:36:48 +00:00
break;
case AF_UNIX:
/* UNIX socket, only the destination is known */
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 13:40:56 +00:00
send_log(fe, LOG_INFO, "Connect to unix:%d (%s/%s)\n",
MEDIUM: stream: move the listener's pointer to the session The listener is session-specific, move it there.
2015-04-03 12:46:27 +00:00
l->luid,
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 13:40:56 +00:00
fe->id, (fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
[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 22:36:48 +00:00
break;
[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-26 00:48:02 +00: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 16:46:57 +00: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-26 00:48:02 +00: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 16:01:06 +00: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 22:36:48 +00: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 18:05:24 +00: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 09:43:32 +00: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-26 00:48:02 +00:00
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 08:45:07 +00:00
conn_get_from_addr(conn);
[MEDIUM] session: move the analysis bit field to the buffer It makes more sense to store the list of analysers in the buffer than in the session since they are precisely plugged onto one buffer.
2008-08-17 13:20:19 +00: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 09:43:32 +00:00
/* try to report the ALPN value when available (also works for NPN) */
MAJOR: connection : Split struct connection into struct connection and struct conn_stream. All the references to connections in the data path from streams and stream_interfaces were changed to use conn_streams. Most functions named "something_conn" were renamed to "something_cs" for this. Sometimes the connection still is what matters (eg during a connection establishment) and were not always renamed. The change is significant and minimal at the same time, and was quite thoroughly tested now. As of this patch, all accesses to the connection from upper layers go through the pass-through mux.
2017-09-13 16:30:23 +00:00
if (conn && conn == cs_conn(objt_cs(s->si[0].end))) {
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 09:43:32 +00: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 18:05:24 +00:00
}
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 08:45:07 +00:00
switch (addr_to_str(&conn->addr.from, 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 22:36:48 +00: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 18:05:24 +00:00
chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [%s:%d] ALPN=%s\n",
REORG/MEDIUM: connection: introduce the notion of connection handle Till now connections used to rely exclusively on file descriptors. It was planned in the past that alternative solutions would be implemented, leading to member "union t" presenting sock.fd only for now. With QUIC, the connection will need to continue to exist but will not rely on a file descriptor but a connection ID. So this patch introduces a "connection handle" which is either a file descriptor or a connection ID, to replace the existing "union t". We've now removed the intermediate "struct sock" which was never used. There is no functional change at all, though the struct connection was inflated by 32 bits on 64-bit platforms due to alignment.
2017-08-24 12:31:19 +00:00
s->uniq_id, fe->id, (unsigned short)l->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 18:05:24 +00:00
pn, get_host_port(&conn->addr.from), 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 22:36:48 +00:00
break;
case AF_UNIX:
/* 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 18:05:24 +00:00
chunk_printf(&trash, "%08x:%s.accept(%04x)=%04x from [unix:%d] ALPN=%s\n",
REORG/MEDIUM: connection: introduce the notion of connection handle Till now connections used to rely exclusively on file descriptors. It was planned in the past that alternative solutions would be implemented, leading to member "union t" presenting sock.fd only for now. With QUIC, the connection will need to continue to exist but will not rely on a file descriptor but a connection ID. So this patch introduces a "connection handle" which is either a file descriptor or a connection ID, to replace the existing "union t". We've now removed the intermediate "struct sock" which was never used. There is no functional change at all, though the struct connection was inflated by 32 bits on 64-bit platforms due to alignment.
2017-08-24 12:31:19 +00:00
s->uniq_id, fe->id, (unsigned short)l->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 18:05:24 +00: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 22:36:48 +00:00
break;
[MINOR] Support of unix listener sockets for debug and log event messages on frontend.c
2010-10-22 14:33:18 +00: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-26 00:48:02 +00:00
BUILD: definitely silence some stupid GCC warnings It's becoming increasingly difficult to ignore unwanted function returns in debug code with gcc. Now even when you try to work around it, it suggests a way to write your code differently. For example : src/frontend.c:187:65: warning: if statement has empty body [-Wempty-body] if (write(1, trash.str, trash.len) < 0) /* shut gcc warning */; ^ src/frontend.c:187:65: note: put the semicolon on a separate line to silence this warning 1 warning generated. This is totally unacceptable, this code already had to be written this way to shut it up in earlier versions. And now it comments the form ? What's the purpose of the C language if you can't write anymore the code that does what you want ? Emeric proposed to just keep a global variable to drain such useless results so that gcc stops complaining all the time it believes people who write code are monkeys. The solution is acceptable because the useless assignment is done only in debug code so it will not impact performance. This patch implements this, until gcc becomes even "smarter" to detect that we tried to cheat.
2013-12-13 14:14:55 +00:00
shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
[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 16:46:57 +00: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-26 00:48:02 +00: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 13:40:56 +00:00
if (fe->mode == PR_MODE_HTTP)
REORG/MAJOR: move session's req and resp channels back into the session The channels were pointers to outside structs and this is not needed anymore since the buffers have moved, but this complicates operations. Move them back into the session so that both channels and stream interfaces are always allocated for a session. Some places (some early sample fetch functions) used to validate that a channel was NULL prior to dereferencing it. Now instead we check if chn->buf is NULL and we force it to remain NULL until the channel is initialized.
2014-11-27 19:45:39 +00:00
s->req.flags |= CF_READ_DONTWAIT; /* 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 13:43:17 +00: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 17:39:22 +00:00
if (unlikely(fe->nb_req_cap > 0)) {
if ((s->req_cap = pool_alloc2(fe->req_cap_pool)) == NULL)
goto out_return; /* no memory */
memset(s->req_cap, 0, fe->nb_req_cap * sizeof(void *));
}
if (unlikely(fe->nb_rsp_cap > 0)) {
if ((s->res_cap = pool_alloc2(fe->rsp_cap_pool)) == NULL)
goto out_free_reqcap; /* no memory */
memset(s->res_cap, 0, fe->nb_rsp_cap * sizeof(void *));
}
if (fe->http_needed) {
/* we have to allocate header indexes only if we know
* that we may make use of them. This of course includes
* (mode == PR_MODE_HTTP).
*/
if (unlikely(!http_alloc_txn(s)))
goto out_free_rspcap; /* no memory */
/* and now initialize the HTTP transaction state */
http_init_txn(s);
}
[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 15:45:26 +00: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 16:46:57 +00: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 16:51:50 +00: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 15:12:40 +00:00
out_free_rspcap:
MEDIUM: http: move header captures from http_txn to struct stream The header captures are now general purpose captures since tcp rules can use them to capture various contents. That removes a dependency on http_txn that appeared in some sample fetch functions and in the order by which captures and http_txn were allocated. Interestingly the reset of the header captures were done at too many places as http_init_txn() used to do it while it was done previously in every call place.
2015-04-03 20:16:32 +00:00
pool_free2(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 15:12:40 +00:00
out_free_reqcap:
MEDIUM: http: move header captures from http_txn to struct stream The header captures are now general purpose captures since tcp rules can use them to capture various contents. That removes a dependency on http_txn that appeared in some sample fetch functions and in the order by which captures and http_txn were allocated. Interestingly the reset of the header captures were done at too many places as http_init_txn() used to do it while it was done previously in every call place.
2015-04-03 20:16:32 +00:00
pool_free2(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 09:56:04 +00: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 16:46:57 +00: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-26 00:48:02 +00: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 21:48:29 +00: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 16:06:15 +00: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 08:06:18 +00: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 13:42:45 +00: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 14:16:37 +00: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 16:53:56 +00: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 07:00:18 +00: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 07:07:19 +00:00
smp->data.u.sint = smp->sess->fe->uuid;
[MEDIUM] Add src dst and dport pattern fetches.
2010-01-04 14:47:45 +00: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 13:08:05 +00: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)
{
smp->data.u.str.str = (char *)smp->sess->fe->id;
if (!smp->data.u.str.str)
return 0;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
smp->data.u.str.len = strlen(smp->data.u.str.str);
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-03 02:57:37 +00: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)
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.u.sint = read_freq_ctr(&args->data.prx->fe_req_per_sec);
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 15:16:54 +00: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 09:37:56 +00: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 15:16:54 +00: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 08:06:18 +00: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 13:42:45 +00: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 17:56:15 +00:00
{
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 14:16:37 +00: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 07:00:18 +00: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 07:07:19 +00:00
smp->data.u.sint = read_freq_ctr(&args->data.prx->fe_sess_per_sec);
[MEDIUM] Add src dst and dport pattern fetches.
2010-01-04 14:47:45 +00: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 14:43:32 +00: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 15:16:54 +00: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 09:37:56 +00: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 15:16:54 +00: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 08:06:18 +00: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 13:42:45 +00: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 22:55:35 +00:00
{
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 14:16:37 +00: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 07:00:18 +00: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 07:07:19 +00:00
smp->data.u.sint = args->data.prx->feconn;
[MINOR] acl: add fe_id/so_id to match frontend's and socket's id
2010-01-12 20:59:30 +00:00
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 22:55:35 +00: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 21:48:29 +00: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 21:16:39 +00:00
static struct sample_fetch_kw_list smp_kws = {ILH, {
MAJOR: sample: converts uint and sint in 64 bits signed integer This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed. This makes easy the usage of integer and clarify signed and unsigned use. With the previous version, signed and unsigned are used ones in place of others, and sometimes the converter loose the sign. For example, divisions are processed with "unsigned", if one entry is negative, the result is wrong. Note that the integer pattern matching and dotted version pattern matching are already working with signed 64 bits integer values. There is one user-visible change : the "uint()" and "sint()" sample fetch functions which used to return a constant integer have been replaced with a new more natural, unified "int()" function. These functions were only introduced in the latest 1.6-dev2 so there's no impact on regular deployments.
2015-07-06 21:43:03 +00:00
{ "fe_conn", smp_fetch_fe_conn, ARG1(1,FE), NULL, SMP_T_SINT, SMP_USE_INTRN, },
{ "fe_id", smp_fetch_fe_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
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 13:08:05 +00:00
{ "fe_name", smp_fetch_fe_name, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
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-03 02:57:37 +00:00
{ "fe_req_rate", smp_fetch_fe_req_rate, ARG1(1,FE), NULL, SMP_T_SINT, SMP_USE_INTRN, },
MAJOR: sample: converts uint and sint in 64 bits signed integer This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed. This makes easy the usage of integer and clarify signed and unsigned use. With the previous version, signed and unsigned are used ones in place of others, and sometimes the converter loose the sign. For example, divisions are processed with "unsigned", if one entry is negative, the result is wrong. Note that the integer pattern matching and dotted version pattern matching are already working with signed 64 bits integer values. There is one user-visible change : the "uint()" and "sint()" sample fetch functions which used to return a constant integer have been replaced with a new more natural, unified "int()" function. These functions were only introduced in the latest 1.6-dev2 so there's no impact on regular deployments.
2015-07-06 21:43:03 +00:00
{ "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 21:48:29 +00:00
{ /* END */ },
}};
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 16:42:05 +00: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 21:16:39 +00: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 21:48:29 +00: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 22:55:35 +00:00
}};
__attribute__((constructor))
[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 19:02:37 +00:00
static void __frontend_init(void)
[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 22:55:35 +00: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 21:48:29 +00:00
sample_register_fetches(&smp_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 22:55:35 +00:00
acl_register_keywords(&acl_kws);
}
[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-26 00:48:02 +00:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink