RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-03-03 01:49:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
82569f9158
haproxy/include/proto/stream_interface.h

154 lines
4.4 KiB
C
Raw Normal View History

[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
/*
[MINOR] http: remove the last call to stream_int_return And remove the now unused function itself too.
2009-10-18 21:56:35 +00:00
* include/proto/stream_interface.h
* This file contains stream_interface function prototypes
*
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 15:47:17 +00:00
* Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
[MINOR] http: remove the last call to stream_int_return And remove the now unused function itself too.
2009-10-18 21:56:35 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
#ifndef _PROTO_STREAM_INTERFACE_H
#define _PROTO_STREAM_INTERFACE_H
#include <stdlib.h>
#include <common/config.h>
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 15:12:34 +00:00
#include <types/session.h>
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
#include <types/stream_interface.h>
MEDIUM: proto_tcp: remove any dependence on stream_interface The last uses of the stream interfaces were in tcp_connect_server() and could easily and more appropriately be moved to its callers, si_connect() and connect_server(), making a lot more sense. Now the function should theorically be usable for health checks. It also appears more obvious that the file is split into two distinct parts : - the protocol layer used at the connection level - the tcp analysers executing tcp-* rules and their samples/acls.
2012-08-30 20:23:13 +00:00
#include <proto/channel.h>
MEDIUM: connection: make use of the new polling functions Now the connection handler, the handshake callbacks and the I/O callbacks make use of the connection-layer polling functions to enable or disable polling on a file descriptor. Some changes still need to be done to avoid using the FD_WAIT_* constants.
2012-08-17 15:33:53 +00:00
#include <proto/connection.h>
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
/* main event functions used to move data between sockets and buffers */
[BUILD] stream_interface: fix conflicting declaration stream_int_check_timeouts was declared void while it's an int.
2009-09-20 18:14:49 +00:00
int stream_int_check_timeouts(struct stream_interface *si);
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
void stream_int_report_error(struct stream_interface *si);
[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
void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg);
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 15:12:34 +00:00
int conn_si_send_proxy(struct connection *conn, unsigned int flag);
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 10:06:26 +00:00
void conn_notify_si(struct connection *conn);
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 17:31:45 +00:00
int stream_int_shutr(struct stream_interface *si);
int stream_int_shutw(struct stream_interface *si);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 19:41:06 +00:00
void si_conn_recv_cb(struct connection *conn);
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 13:09:53 +00:00
void si_conn_send_cb(struct connection *conn);
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 13:38:41 +00:00
void stream_sock_read0(struct stream_interface *si);
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
extern struct si_ops si_embedded_ops;
extern struct si_ops si_task_ops;
extern struct si_ops si_conn_ops;
extern struct app_cb si_conn_cb;
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 15:15:39 +00:00
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 18:57:35 +00:00
struct task *stream_int_register_handler(struct stream_interface *si,
[MINOR] stream_interface: make use of an applet descriptor for IO handlers I/O handlers are still delicate to manipulate. They have no type, they're just raw functions which have no knowledge of themselves. Let's have them declared as applets once for all. That way we can have multiple applets share the same handler functions and we can store their names there. When we later need to add more parameters (eg: usage stats), we'll be able to do so in the applets themselves. The CLI functions has been prefixed with "cli" instead of "stats" as it's clearly what is going on there. The applet descriptor in the stream interface should get all the applet specific data (st0, ...) but this will be done in the next patch so that we don't pollute this one too much.
2011-02-13 12:16:36 +00:00
struct si_applet *app);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 18:57:35 +00:00
struct task *stream_int_register_handler_task(struct stream_interface *si,
struct task *(*fct)(struct task *));
void stream_int_unregister_handler(struct stream_interface *si);
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
static inline const struct protocol *si_ctrl(struct stream_interface *si)
{
return si->conn.ctrl;
}
REORG/MINOR: stream_interface: move si->fd to struct connection The socket fd is used only when in socket mode and with a connection.
2012-05-21 14:47:54 +00:00
static inline int si_fd(struct stream_interface *si)
{
return si->conn.t.sock.fd;
}
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
static inline void si_prepare_conn(struct stream_interface *si, const struct protocol *ctrl, const struct data_ops *ops)
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 15:15:39 +00:00
{
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
si->ops = &si_conn_ops;
CLEANUP: connection: offer conn_prepare() to set up a connection This will be used by checks as well as stream interfaces.
2012-09-24 15:15:42 +00:00
conn_prepare(&si->conn, &si_conn_cb, ctrl, ops);
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 15:15:39 +00:00
}
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
static inline void si_prepare_embedded(struct stream_interface *si)
{
si->ops = &si_embedded_ops;
CLEANUP: connection: offer conn_prepare() to set up a connection This will be used by checks as well as stream interfaces.
2012-09-24 15:15:42 +00:00
conn_prepare(&si->conn, NULL, NULL, NULL);
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
}
static inline void si_prepare_task(struct stream_interface *si)
{
si->ops = &si_task_ops;
CLEANUP: connection: offer conn_prepare() to set up a connection This will be used by checks as well as stream interfaces.
2012-09-24 15:15:42 +00:00
conn_prepare(&si->conn, NULL, NULL, NULL);
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
}
BUG/MEDIUM: stream_interface: restore get_src/get_dst Commit e164e7a removed get_src/get_dst setting in the stream interfaces but forgot to set it in proto_tcp. Get the feature back because we need it for logging, transparent mode, ACLs etc... We now rely on the stream interface direction to know what syscall to use. One benefit of doing it this way is that we don't use getsockopt() anymore on outgoing stream interfaces nor on UNIX sockets.
2012-05-11 14:16:40 +00:00
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
/* Sends a shutr to the connection using the data layer */
static inline void si_shutr(struct stream_interface *si)
{
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 17:31:45 +00:00
if (stream_int_shutr(si))
MEDIUM: connection: make use of the new polling functions Now the connection handler, the handshake callbacks and the I/O callbacks make use of the connection-layer polling functions to enable or disable polling on a file descriptor. Some changes still need to be done to avoid using the FD_WAIT_* constants.
2012-08-17 15:33:53 +00:00
conn_data_stop_recv(&si->conn);
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
}
/* Sends a shutw to the connection using the data layer */
static inline void si_shutw(struct stream_interface *si)
{
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 17:31:45 +00:00
if (stream_int_shutw(si))
MEDIUM: connection: make use of the new polling functions Now the connection handler, the handshake callbacks and the I/O callbacks make use of the connection-layer polling functions to enable or disable polling on a file descriptor. Some changes still need to be done to avoid using the FD_WAIT_* constants.
2012-08-17 15:33:53 +00:00
conn_data_stop_send(&si->conn);
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
}
/* Calls the data state update on the stream interfaace */
static inline void si_update(struct stream_interface *si)
{
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
si->ops->update(si);
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
}
/* Calls chk_rcv on the connection using the data layer */
static inline void si_chk_rcv(struct stream_interface *si)
{
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
si->ops->chk_rcv(si);
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
}
/* Calls chk_snd on the connection using the data layer */
static inline void si_chk_snd(struct stream_interface *si)
{
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 16:12:41 +00:00
si->ops->chk_snd(si);
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
}
/* Calls chk_snd on the connection using the ctrl layer */
static inline int si_connect(struct stream_interface *si)
{
MEDIUM: proto_tcp: remove any dependence on stream_interface The last uses of the stream interfaces were in tcp_connect_server() and could easily and more appropriately be moved to its callers, si_connect() and connect_server(), making a lot more sense. Now the function should theorically be usable for health checks. It also appears more obvious that the file is split into two distinct parts : - the protocol layer used at the connection level - the tcp analysers executing tcp-* rules and their samples/acls.
2012-08-30 20:23:13 +00:00
int ret;
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
if (unlikely(!si_ctrl(si) || !si_ctrl(si)->connect))
return SN_ERR_INTERNAL;
MEDIUM: proto_tcp: remove any dependence on stream_interface The last uses of the stream interfaces were in tcp_connect_server() and could easily and more appropriately be moved to its callers, si_connect() and connect_server(), making a lot more sense. Now the function should theorically be usable for health checks. It also appears more obvious that the file is split into two distinct parts : - the protocol layer used at the connection level - the tcp analysers executing tcp-* rules and their samples/acls.
2012-08-30 20:23:13 +00:00
ret = si_ctrl(si)->connect(&si->conn, !channel_is_empty(si->ob));
if (ret != SN_ERR_NONE)
return ret;
/* needs src ip/port for logging */
if (si->flags & SI_FL_SRC_ADDR)
conn_get_from_addr(&si->conn);
/* Prepare to send a few handshakes related to the on-wire protocol. */
if (si->send_proxy_ofs)
si->conn.flags |= CO_FL_SI_SEND_PROXY;
/* we need to be notified about connection establishment */
si->conn.flags |= CO_FL_NOTIFY_SI;
/* we're in the process of establishing a connection */
si->state = SI_ST_CON;
return ret;
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 14:31:45 +00:00
}
BUG/MEDIUM: stream_interface: restore get_src/get_dst Commit e164e7a removed get_src/get_dst setting in the stream interfaces but forgot to set it in proto_tcp. Get the feature back because we need it for logging, transparent mode, ACLs etc... We now rely on the stream interface direction to know what syscall to use. One benefit of doing it this way is that we don't use getsockopt() anymore on outgoing stream interfaces nor on UNIX sockets.
2012-05-11 14:16:40 +00:00
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 05:26:53 +00:00
#endif /* _PROTO_STREAM_INTERFACE_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink