upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-02-17 09:37:53 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 4
haproxy/src/stream_interface.c

908 lines
29 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 00:26:53 -05:00
/*
* Functions managing stream_interface structures
*
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 11:47:17 -04:00
* Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
[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 00:26:53 -05: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>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <common/compat.h>
#include <common/config.h>
#include <common/debug.h>
#include <common/standard.h>
#include <common/ticks.h>
#include <common/time.h>
#include <proto/buffers.h>
REORG: connection: replace si_data_close() with conn_data_close() This close function only applies to connection-specific parts and the stream-interface entry may soon disappear. Move this to the connection instead.
2012-08-06 09:06:49 -04: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 00:26:53 -05:00
#include <proto/fd.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 11:12:34 -04:00
#include <proto/frontend.h>
REORG: use the name sock_raw instead of stream_sock We'll soon have an SSL socket layer, and in order to ease the difference between the two, we use the name "sock_raw" to designate the one which directly talks to the sockets without any conversion.
2012-05-11 08:23:52 -04:00
#include <proto/sock_raw.h>
[BUILD] stream_interface: fix conflicting declaration stream_int_check_timeouts was declared void while it's an int.
2009-09-20 14:14:49 -04:00
#include <proto/stream_interface.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 00:26:53 -05:00
#include <proto/task.h>
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
#include <types/pipe.h>
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 11:47:17 -04:00
/* socket functions used when running a stream interface as a task */
static void stream_int_update(struct stream_interface *si);
static void stream_int_update_embedded(struct stream_interface *si);
static void stream_int_chk_rcv(struct stream_interface *si);
static void stream_int_chk_snd(struct stream_interface *si);
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
/* socket operations for embedded tasks */
struct sock_ops stream_int_embedded = {
.update = stream_int_update_embedded,
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 13:31:45 -04:00
.shutr = NULL,
.shutw = NULL,
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
.chk_rcv = stream_int_chk_rcv,
.chk_snd = stream_int_chk_snd,
.read = NULL,
.write = NULL,
MINOR: stream_interface: add a data channel close function This function will be called later when splitting the shutdown in two steps. It will be needed by SSL and for remote socket operations to release unused contexts.
2012-05-21 11:28:50 -04:00
.close = NULL,
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
};
/* socket operations for external tasks */
struct sock_ops stream_int_task = {
.update = stream_int_update,
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 13:31:45 -04:00
.shutr = NULL,
.shutw = NULL,
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
.chk_rcv = stream_int_chk_rcv,
.chk_snd = stream_int_chk_snd,
.read = NULL,
.write = NULL,
MINOR: stream_interface: add a data channel close function This function will be called later when splitting the shutdown in two steps. It will be needed by SSL and for remote socket operations to release unused contexts.
2012-05-21 11:28:50 -04:00
.close = NULL,
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04: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 00:26:53 -05:00
/*
* This function only has to be called once after a wakeup event in case of
* suspected timeout. It controls the stream interface timeouts and sets
* si->flags accordingly. It does NOT close anything, as this timeout may
* be used for any purpose. It returns 1 if the timeout fired, otherwise
* zero.
*/
int stream_int_check_timeouts(struct stream_interface *si)
{
if (tick_is_expired(si->exp, now_ms)) {
si->flags |= SI_FL_EXP;
return 1;
}
return 0;
}
[MAJOR] complete layer4/7 separation All the processing has now completely been split in layers. As of now, everything is still in process_session() which is not the right place, but the code sequence works. Timeouts, retries, errors, all work. The shutdown sequence has been strictly applied: BF_SHUTR/BF_SHUTW are only assigned by lower layers. Upper layers can only indicate their wish to close using BF_SHUTR_NOW and BF_SHUTW_NOW. When a shutdown is performed on a stream interface, the buffer flags are updated accordingly and re-checked by upper layers. A lot of care has been taken to ensure that aborts during intermediate connection setups are correctly handled and shutdowns correctly propagated to both buffers. A future evolution would consist in ensuring that BF_SHUT?_NOW may be set at any time, and applies only when the buffer is empty. This might help with error messages, but might complicate the processing of data remaining in buffers. Some useless buffer flag combinations have been removed. Stat counters are still broken (eg: per-server total number of sessions). Error messages should be delayed to the close instant and be produced by protocol. Many functions must now move to proper locations.
2008-11-30 12:14:12 -05:00
/* to be called only when in SI_ST_DIS with SI_FL_ERR */
[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 00:26:53 -05:00
void stream_int_report_error(struct stream_interface *si)
{
if (!si->err_type)
si->err_type = SI_ET_DATA_ERR;
si->ob->flags |= BF_WRITE_ERROR;
si->ib->flags |= BF_READ_ERROR;
}
[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 13:48:07 -05:00
/*
* Returns a message to the client ; the connection is shut down for read,
* and the request is cleared so that no server connection can be initiated.
* The buffer is marked for read shutdown on the other side to protect the
* message, and the buffer write is enabled. The message is contained in a
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
* "chunk". If it is null, then an empty message is used. The reply buffer does
* not need to be empty before this, and its contents will not be overwritten.
* The primary goal of this function is to return error messages to a client.
[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 13:48:07 -05:00
*/
void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg)
{
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
buffer_auto_read(si->ib);
[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 13:48:07 -05:00
buffer_abort(si->ib);
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
buffer_auto_close(si->ib);
buffer_erase(si->ib);
[BUG] stream_interface: truncate buffers when sending error messages When an error message is returned to a client, all buffer contents were left intact. Since the analysers were removed, the potentially invalid data that were read had a chance to be sent too. Now we ensure we only keep the already scheduled data in the buffer and we truncate it after that. That means that responses with data that must be blocked will really be blocked, and that incorrectly chunked data will be stopped at the point where the chunking fails.
2010-12-12 07:06:00 -05:00
MEDIUM: buffers: rename a number of buffer management functions The following renaming took place : 1) buffer input functions buffer_put_block => bi_putblk buffer_put_char => bi_putchr buffer_put_string => bi_putstr buffer_put_chunk => bi_putchk buffer_feed => bi_putstr buffer_feed_chunk => bi_putchk buffer_cut_tail => bi_erase buffer_ignore => bi_fast_delete 2) buffer output functions buffer_get_char => bo_getchr buffer_get_line => bo_getline buffer_get_block => bo_getblk buffer_skip => bo_skip buffer_write => bo_inject 3) buffer input avail/full functions were introduced : bi_avail bi_full
2012-05-07 05:56:55 -04:00
bi_erase(si->ob);
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
if (likely(msg && msg->len))
MEDIUM: buffers: rename a number of buffer management functions The following renaming took place : 1) buffer input functions buffer_put_block => bi_putblk buffer_put_char => bi_putchr buffer_put_string => bi_putstr buffer_put_chunk => bi_putchk buffer_feed => bi_putstr buffer_feed_chunk => bi_putchk buffer_cut_tail => bi_erase buffer_ignore => bi_fast_delete 2) buffer output functions buffer_get_char => bo_getchr buffer_get_line => bo_getline buffer_get_block => bo_getblk buffer_skip => bo_skip buffer_write => bo_inject 3) buffer input avail/full functions were introduced : bi_avail bi_full
2012-05-07 05:56:55 -04:00
bo_inject(si->ob, msg->str, msg->len);
[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 13:48:07 -05:00
si->ob->wex = tick_add_ifset(now_ms, si->ob->wto);
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
buffer_auto_read(si->ob);
[MAJOR] buffers: split BF_WRITE_ENA into BF_AUTO_CONNECT and BF_AUTO_CLOSE The BF_WRITE_ENA buffer flag became very complex to deal with, because it was used to : - enable automatic connection - enable close forwarding - enable data forwarding The last point was not very true anymore since we introduced ->send_max, but still the test remained everywhere. This was causing issues such as impossibility to connect without forwarding data, impossibility to prevent closing when data was forwarded, etc... This patch clarifies the situation by getting rid of this multi-purpose flag and replacing it with : - data forwarding based only on ->send_max || ->pipe ; - a new BF_AUTO_CONNECT flag to allow automatic connection and only that ; - ability to perform an automatic connection when ->send_max or ->pipe indicate that data is waiting to leave the buffer ; - a new BF_AUTO_CLOSE flag to let the producer automatically set the BF_SHUTW_NOW flag when it gets a BF_SHUTR. During this cleanup, it was discovered that some tests were performed twice, or that the BF_HIJACK flag was still tested, which is not needed anymore since ->send_max replcaed it. These places have been fixed too. These cleanups have also revealed a few areas where the other flags such as BF_EMPTY are not cleanly used. This will be an opportunity for a second patch.
2009-09-19 15:04:57 -04:00
buffer_auto_close(si->ob);
[MINOR] new function stream_int_cond_close() This one will be used to conditionally send a message upon a close on a stream interface. It will not overwrite any existing data.
2009-12-27 16:51:06 -05:00
buffer_shutr_now(si->ob);
}
[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 14:57:35 -04:00
/* default update function for scheduled tasks, not used for embedded tasks */
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 11:47:17 -04:00
static void stream_int_update(struct stream_interface *si)
[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 14:57:35 -04:00
{
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
/* default update function for embedded tasks, to be used at the end of the i/o handler */
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 11:47:17 -04:00
static void stream_int_update_embedded(struct stream_interface *si)
[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 14:57:35 -04:00
{
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
int old_flags = si->flags;
[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 14:57:35 -04:00
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
if (si->state != SI_ST_EST)
return;
if ((si->ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == (BF_OUT_EMPTY|BF_SHUTW_NOW))
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 10:31:45 -04:00
si_shutw(si);
[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 14:57:35 -04:00
if ((si->ob->flags & (BF_FULL|BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == 0)
si->flags |= SI_FL_WAIT_DATA;
[MEDIUM] stream_int: adjust WAIT_ROOM handling When applets write data, they generall cannot fill the buffer, so as soon as we find a non-empty buffer, we're sure we're missing some room.
2009-10-04 11:18:35 -04:00
/* we're almost sure that we need some space if the buffer is not
* empty, even if it's not full, because the applets can't fill it.
*/
[MAJOR] buffer: flag BF_DONT_READ to disable reads when not required When processing a GET or HEAD request in close mode, we know we don't need to read anything anymore on the socket, so we can disable it. Doing this can save up to 40% of the recv calls, and half of the epoll_ctl calls. For this we need a buffer flag indicating that we're not interesting in reading anymore. Right now, this flag also disables both polled reads. We might benefit from disabling only speculative reads, but we will need at least this flag when we want to support keepalive anyway. Currently we don't disable the flag on completion, but it does not matter as we close ASAP when performing the shutw().
2009-10-17 08:37:52 -04:00
if ((si->ib->flags & (BF_SHUTR|BF_OUT_EMPTY|BF_DONT_READ)) == 0)
[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 14:57:35 -04:00
si->flags |= SI_FL_WAIT_ROOM;
[MEDIUM] new option "independant-streams" to stop updating read timeout on writes By default, when data is sent over a socket, both the write timeout and the read timeout for that socket are refreshed, because we consider that there is activity on that socket, and we have no other means of guessing if we should receive data or not. While this default behaviour is desirable for almost all applications, there exists a situation where it is desirable to disable it, and only refresh the read timeout if there are incoming data. This happens on sessions with large timeouts and low amounts of exchanged data such as telnet session. If the server suddenly disappears, the output data accumulates in the system's socket buffers, both timeouts are correctly refreshed, and there is no way to know the server does not receive them, so we don't timeout. However, when the underlying protocol always echoes sent data, it would be enough by itself to detect the issue using the read timeout. Note that this problem does not happen with more verbose protocols because data won't accumulate long in the socket buffers. When this option is set on the frontend, it will disable read timeout updates on data sent to the client. There probably is little use of this case. When the option is set on the backend, it will disable read timeout updates on data sent to the server. Doing so will typically break large HTTP posts from slow lines, so use it with caution.
2009-10-03 16:01:18 -04:00
if (si->ob->flags & BF_WRITE_ACTIVITY) {
[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 14:57:35 -04:00
if (tick_isset(si->ob->wex))
si->ob->wex = tick_add_ifset(now_ms, si->ob->wto);
}
[MEDIUM] new option "independant-streams" to stop updating read timeout on writes By default, when data is sent over a socket, both the write timeout and the read timeout for that socket are refreshed, because we consider that there is activity on that socket, and we have no other means of guessing if we should receive data or not. While this default behaviour is desirable for almost all applications, there exists a situation where it is desirable to disable it, and only refresh the read timeout if there are incoming data. This happens on sessions with large timeouts and low amounts of exchanged data such as telnet session. If the server suddenly disappears, the output data accumulates in the system's socket buffers, both timeouts are correctly refreshed, and there is no way to know the server does not receive them, so we don't timeout. However, when the underlying protocol always echoes sent data, it would be enough by itself to detect the issue using the read timeout. Note that this problem does not happen with more verbose protocols because data won't accumulate long in the socket buffers. When this option is set on the frontend, it will disable read timeout updates on data sent to the client. There probably is little use of this case. When the option is set on the backend, it will disable read timeout updates on data sent to the server. Doing so will typically break large HTTP posts from slow lines, so use it with caution.
2009-10-03 16:01:18 -04:00
if (si->ib->flags & BF_READ_ACTIVITY ||
(si->ob->flags & BF_WRITE_ACTIVITY && !(si->flags & SI_FL_INDEP_STR))) {
if (tick_isset(si->ib->rex))
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
}
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
/* save flags to detect changes */
old_flags = si->flags;
[MAJOR] buffer: flag BF_DONT_READ to disable reads when not required When processing a GET or HEAD request in close mode, we know we don't need to read anything anymore on the socket, so we can disable it. Doing this can save up to 40% of the recv calls, and half of the epoll_ctl calls. For this we need a buffer flag indicating that we're not interesting in reading anymore. Right now, this flag also disables both polled reads. We might benefit from disabling only speculative reads, but we will need at least this flag when we want to support keepalive anyway. Currently we don't disable the flag on completion, but it does not matter as we close ASAP when performing the shutw().
2009-10-17 08:37:52 -04:00
if (likely((si->ob->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
[MEDIUM] stream_int: adjust WAIT_ROOM handling When applets write data, they generall cannot fill the buffer, so as soon as we find a non-empty buffer, we're sure we're missing some room.
2009-10-04 11:18:35 -04:00
(si->ob->prod->flags & SI_FL_WAIT_ROOM)))
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 10:31:45 -04:00
si_chk_rcv(si->ob->prod);
[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 14:57:35 -04:00
[MEDIUM] stream_int: adjust WAIT_ROOM handling When applets write data, they generall cannot fill the buffer, so as soon as we find a non-empty buffer, we're sure we're missing some room.
2009-10-04 11:18:35 -04:00
if (((si->ib->flags & (BF_READ_PARTIAL|BF_OUT_EMPTY)) == BF_READ_PARTIAL) &&
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
(si->ib->cons->flags & SI_FL_WAIT_DATA)) {
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 10:31:45 -04:00
si_chk_snd(si->ib->cons);
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
/* check if the consumer has freed some space */
if (!(si->ib->flags & BF_FULL))
si->flags &= ~SI_FL_WAIT_ROOM;
}
[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 14:57:35 -04:00
/* Note that we're trying to wake up in two conditions here :
* - special event, which needs the holder task attention
* - status indicating that the applet can go on working. This
* is rather hard because we might be blocking on output and
* don't want to wake up on input and vice-versa. The idea is
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
* to only rely on the changes the chk_* might have performed.
[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 14:57:35 -04:00
*/
if (/* check stream interface changes */
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
((old_flags & ~si->flags) & (SI_FL_WAIT_ROOM|SI_FL_WAIT_DATA)) ||
/* changes on the production side */
(si->ib->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
si->state != SI_ST_EST ||
(si->flags & SI_FL_ERR) ||
((si->ib->flags & BF_READ_PARTIAL) &&
(!si->ib->to_forward || si->ib->cons->state != SI_ST_EST)) ||
/* changes on the consumption side */
(si->ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR)) ||
((si->ob->flags & BF_WRITE_ACTIVITY) &&
((si->ob->flags & BF_SHUTW) ||
si->ob->prod->state != SI_ST_EST ||
((si->ob->flags & BF_OUT_EMPTY) && !si->ob->to_forward)))) {
[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 14:57:35 -04:00
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
if (si->ib->flags & BF_READ_ACTIVITY)
si->ib->flags &= ~BF_READ_DONTWAIT;
[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 14:57:35 -04:00
}
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 13:31:45 -04:00
/*
* This function performs a shutdown-read on a stream interface in a connected
* or init state (it does nothing for other states). It either shuts the read
* side or marks itself as closed. The buffer flags are updated to reflect the
* new state. If the stream interface has SI_FL_NOHALF, we also forward the
* close to the write side. If a control layer is defined, then it is supposed
* to be a socket layer and file descriptors are then shutdown or closed
* accordingly. If no control layer is defined, then the SI is supposed to be
* an embedded one and the owner task is woken up if it exists. The function
* does not disable polling on the FD by itself, it returns non-zero instead
* if the caller needs to do so (except when the FD is deleted where this is
* implicit).
*/
int stream_int_shutr(struct stream_interface *si)
[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 14:57:35 -04:00
{
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 13:31:45 -04:00
struct connection *conn = &si->conn;
[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 14:57:35 -04:00
si->ib->flags &= ~BF_SHUTR_NOW;
if (si->ib->flags & BF_SHUTR)
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 13:31:45 -04:00
return 0;
[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 14:57:35 -04:00
si->ib->flags |= BF_SHUTR;
si->ib->rex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_ROOM;
if (si->state != SI_ST_EST && si->state != SI_ST_CON)
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 13:31:45 -04:00
return 0;
[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 14:57:35 -04:00
if (si->ob->flags & BF_SHUTW) {
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 13:31:45 -04:00
conn_data_close(&si->conn);
if (conn->ctrl)
fd_delete(si_fd(si));
[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 14:57:35 -04:00
si->state = SI_ST_DIS;
si->exp = TICK_ETERNITY;
[BUG] stream_interface: only call si->release when both dirs are closed si->release() was called each time we closed one direction of a stream interface, while it should only have been called when both sides are closed. This bug is specific to 1.5 and only affects embedded tasks.
2010-09-07 10:16:50 -04:00
if (si->release)
si->release(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 13:31:45 -04:00
else if (si->flags & SI_FL_NOHALF) {
/* we want to immediately forward this close to the write side */
return stream_int_shutw(si);
}
else if (conn->ctrl) {
/* we want the caller to disable polling on this FD */
return 1;
}
[MEDIUM] stream-interface: add a ->release callback When a connection is closed on a stream interface, some iohandlers will need to be informed in order to release some resources. This normally happens upon a shutr+shutw. It is the equivalent of the fd_delete() call which is done for real sockets, except that this time we release internal resources. It can also be used with real sockets because it does not cost anything else and might one day be useful.
2010-07-02 05:18:03 -04:00
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 13:31:45 -04:00
/* note that if the task exists, it must unregister itself once it runs */
if (!conn->ctrl && !(si->flags & SI_FL_DONT_WAKE) && si->owner)
[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 14:57:35 -04:00
task_wakeup(si->owner, TASK_WOKEN_IO);
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 13:31:45 -04:00
return 0;
[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 14:57:35 -04:00
}
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 13:31:45 -04:00
/*
* This function performs a shutdown-write on a stream interface in a connected or
* init state (it does nothing for other states). It either shuts the write side
* or marks itself as closed. The buffer flags are updated to reflect the new state.
* It does also close everything if the SI was marked as being in error state. If
* there is a data-layer shutdown, it is called. If a control layer is defined, then
* it is supposed to be a socket layer and file descriptors are then shutdown or
* closed accordingly. If no control layer is defined, then the SI is supposed to
* be an embedded one and the owner task is woken up if it exists. The function
* does not disable polling on the FD by itself, it returns non-zero instead if
* the caller needs to do so (except when the FD is deleted where this is implicit).
*/
int stream_int_shutw(struct stream_interface *si)
[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 14:57:35 -04:00
{
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 13:31:45 -04:00
struct connection *conn = &si->conn;
[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 14:57:35 -04:00
si->ob->flags &= ~BF_SHUTW_NOW;
if (si->ob->flags & BF_SHUTW)
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 13:31:45 -04:00
return 0;
[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 14:57:35 -04:00
si->ob->flags |= BF_SHUTW;
si->ob->wex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_DATA;
switch (si->state) {
case SI_ST_EST:
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 13:31:45 -04:00
/* we have to shut before closing, otherwise some short messages
* may never leave the system, especially when there are remaining
* unread data in the socket input buffer, or when nolinger is set.
* However, if SI_FL_NOLINGER is explicitly set, we know there is
* no risk so we close both sides immediately.
*/
if (si->flags & SI_FL_ERR) {
/* quick close, the socket is already shut. Remove pending flags. */
si->flags &= ~SI_FL_NOLINGER;
} else if (si->flags & SI_FL_NOLINGER) {
si->flags &= ~SI_FL_NOLINGER;
if (conn->ctrl) {
setsockopt(si_fd(si), SOL_SOCKET, SO_LINGER,
(struct linger *) &nolinger, sizeof(struct linger));
}
/* unclean data-layer shutdown */
if (conn->data && conn->data->shutw)
conn->data->shutw(conn, 0);
} else {
/* clean data-layer shutdown */
if (conn->data && conn->data->shutw)
conn->data->shutw(conn, 1);
if (!(si->flags & SI_FL_NOHALF)) {
/* We shutdown transport layer */
if (conn->ctrl)
shutdown(si_fd(si), SHUT_WR);
if (!(si->ib->flags & (BF_SHUTR|BF_DONT_READ))) {
/* OK just a shutw, but we want the caller
* to disable polling on this FD if exists.
*/
return !!conn->ctrl;
}
}
}
[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 14:57:35 -04:00
/* fall through */
case SI_ST_CON:
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 13:31:45 -04:00
/* we may have to close a pending connection, and mark the
* response buffer as shutr
*/
conn_data_close(&si->conn);
if (conn->ctrl)
fd_delete(si_fd(si));
/* fall through */
[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 14:57:35 -04:00
case SI_ST_CER:
[CRITICAL] session: correctly leave turn-around and queue states on abort When a client connection aborts while the server-side connection is in turn-around after a failed connection attempt, the turn-around timeout is reset in shutw() but the state is not changed. The session then remains stuck in this state forever. Change the QUE and TAR states to DIS just as we do for CER to fix this. This patch should be backported to 1.4.
2010-12-29 08:03:02 -05:00
case SI_ST_QUE:
case SI_ST_TAR:
[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 14:57:35 -04:00
si->state = SI_ST_DIS;
[BUG] stream_interface: only call si->release when both dirs are closed si->release() was called each time we closed one direction of a stream interface, while it should only have been called when both sides are closed. This bug is specific to 1.5 and only affects embedded tasks.
2010-09-07 10:16:50 -04:00
if (si->release)
si->release(si);
[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 14:57:35 -04:00
default:
si->flags &= ~SI_FL_WAIT_ROOM;
si->ib->flags |= BF_SHUTR;
si->ib->rex = TICK_ETERNITY;
si->exp = TICK_ETERNITY;
}
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 13:31:45 -04:00
/* note that if the task exists, it must unregister itself once it runs */
if (!conn->ctrl && !(si->flags & SI_FL_DONT_WAKE) && si->owner)
[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 14:57:35 -04:00
task_wakeup(si->owner, TASK_WOKEN_IO);
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 13:31:45 -04:00
return 0;
[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 14:57:35 -04:00
}
/* default chk_rcv function for scheduled tasks */
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 11:47:17 -04:00
static void stream_int_chk_rcv(struct stream_interface *si)
[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 14:57:35 -04:00
{
struct buffer *ib = si->ib;
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
return;
[MAJOR] buffer: flag BF_DONT_READ to disable reads when not required When processing a GET or HEAD request in close mode, we know we don't need to read anything anymore on the socket, so we can disable it. Doing this can save up to 40% of the recv calls, and half of the epoll_ctl calls. For this we need a buffer flag indicating that we're not interesting in reading anymore. Right now, this flag also disables both polled reads. We might benefit from disabling only speculative reads, but we will need at least this flag when we want to support keepalive anyway. Currently we don't disable the flag on completion, but it does not matter as we close ASAP when performing the shutw().
2009-10-17 08:37:52 -04:00
if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
[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 14:57:35 -04:00
/* stop reading */
[MAJOR] buffer: flag BF_DONT_READ to disable reads when not required When processing a GET or HEAD request in close mode, we know we don't need to read anything anymore on the socket, so we can disable it. Doing this can save up to 40% of the recv calls, and half of the epoll_ctl calls. For this we need a buffer flag indicating that we're not interesting in reading anymore. Right now, this flag also disables both polled reads. We might benefit from disabling only speculative reads, but we will need at least this flag when we want to support keepalive anyway. Currently we don't disable the flag on completion, but it does not matter as we close ASAP when performing the shutw().
2009-10-17 08:37:52 -04:00
if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
[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 14:57:35 -04:00
si->flags |= SI_FL_WAIT_ROOM;
}
else {
/* (re)start reading */
si->flags &= ~SI_FL_WAIT_ROOM;
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
}
/* default chk_snd function for scheduled tasks */
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 11:47:17 -04:00
static void stream_int_chk_snd(struct stream_interface *si)
[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 14:57:35 -04:00
{
struct buffer *ob = si->ob;
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
if (unlikely(si->state != SI_ST_EST || (si->ob->flags & BF_SHUTW)))
return;
if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
(ob->flags & BF_OUT_EMPTY)) /* called with nothing to send ! */
return;
/* Otherwise there are remaining data to be sent in the buffer,
* so we tell the handler.
*/
si->flags &= ~SI_FL_WAIT_DATA;
if (!tick_isset(ob->wex))
ob->wex = tick_add_ifset(now_ms, ob->wto);
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
[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 07:16:36 -05:00
/* Register an applet to handle a stream_interface as part of the stream
[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 14:57:35 -04:00
* interface's owner task, which is returned. The SI will wake it up everytime
[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 07:16:36 -05:00
* it is solicited. The task's processing function must call the applet's
[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 14:57:35 -04:00
* function before returning. It must be deleted by the task handler using
[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 07:16:36 -05:00
* stream_int_unregister_handler(), possibly from within the function itself.
BUG/MEDIUM: register peer sync handler in the proper order Herv Commowick reported a failure to resync upon restart caused by a segfault on the old process. This is due to the data_ctx of the connection being initialized after the stream interface.
2012-05-31 08:16:59 -04:00
* It also pre-initializes applet.state to zero and the connection context
* to NULL.
[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 14:57:35 -04:00
*/
[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 07:16:36 -05:00
struct task *stream_int_register_handler(struct stream_interface *si, 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 14:57:35 -04:00
{
[MINOR] Fix build error in stream_int_register_handler() There is no parameter or variable fct in stream_int_register_handler() so the build fails when DPRINTF is active.
2011-08-12 19:03:51 -04:00
DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", app, si, si->owner);
[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 14:57:35 -04:00
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
stream_interface_prepare(si, &stream_int_embedded);
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 10:31:45 -04:00
si->conn.ctrl = NULL;
[CLEANUP] stream_interface: use inline functions to manipulate targets The connection target involves a type and a union of pointers, let's make the code cleaner using simple wrappers.
2011-03-10 08:03:36 -05:00
set_target_applet(&si->target, app);
MINOR: Add release callback to si_applet
2012-04-02 21:57:53 -04:00
si->release = app->release;
[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 14:57:35 -04:00
si->flags |= SI_FL_WAIT_DATA;
return si->owner;
}
/* Register a function to handle a stream_interface as a standalone task. The
* new task itself is returned and is assigned as si->owner. The stream_interface
* pointer will be pointed to by the task's context. The handler can be detached
* by using stream_int_unregister_handler().
[CLEANUP] stream_interface: remove the applet.handler pointer Now that we have the target pointer and type in the stream interface, we don't need the applet.handler pointer anymore. That makes the code somewhat cleaner because we know we're dealing with an applet by checking its type instead of checking the pointer is not null.
2011-03-10 05:17:02 -05:00
* FIXME: the code should be updated to ensure that we don't change si->owner
* anymore as this is not needed. However, process_session still relies on it.
[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 14:57:35 -04:00
*/
struct task *stream_int_register_handler_task(struct stream_interface *si,
struct task *(*fct)(struct task *))
{
struct task *t;
DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", fct, si, si->owner);
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
stream_interface_prepare(si, &stream_int_task);
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 10:31:45 -04:00
si->conn.ctrl = NULL;
[CLEANUP] stream_interface: use inline functions to manipulate targets The connection target involves a type and a union of pointers, let's make the code cleaner using simple wrappers.
2011-03-10 08:03:36 -05:00
clear_target(&si->target);
[MEDIUM] stream-interface: add a ->release callback When a connection is closed on a stream interface, some iohandlers will need to be informed in order to release some resources. This normally happens upon a shutr+shutw. It is the equivalent of the fd_delete() call which is done for real sockets, except that this time we release internal resources. It can also be used with real sockets because it does not cost anything else and might one day be useful.
2010-07-02 05:18:03 -04:00
si->release = NULL;
[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 14:57:35 -04:00
si->flags |= SI_FL_WAIT_DATA;
t = task_new();
si->owner = t;
if (!t)
return t;
[CLEANUP] stream_interface: remove the applet.handler pointer Now that we have the target pointer and type in the stream interface, we don't need the applet.handler pointer anymore. That makes the code somewhat cleaner because we know we're dealing with an applet by checking its type instead of checking the pointer is not null.
2011-03-10 05:17:02 -05:00
[CLEANUP] stream_interface: use inline functions to manipulate targets The connection target involves a type and a union of pointers, let's make the code cleaner using simple wrappers.
2011-03-10 08:03:36 -05:00
set_target_task(&si->target, t);
[CLEANUP] stream_interface: remove the applet.handler pointer Now that we have the target pointer and type in the stream interface, we don't need the applet.handler pointer anymore. That makes the code somewhat cleaner because we know we're dealing with an applet by checking its type instead of checking the pointer is not null.
2011-03-10 05:17:02 -05: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 14:57:35 -04:00
t->process = fct;
t->context = si;
task_wakeup(si->owner, TASK_WOKEN_INIT);
return t;
}
/* Unregister a stream interface handler. This must be called by the handler task
* itself when it detects that it is in the SI_ST_DIS state. This function can
* both detach standalone handlers and embedded handlers.
*/
void stream_int_unregister_handler(struct stream_interface *si)
{
[CLEANUP] stream_interface: remove the applet.handler pointer Now that we have the target pointer and type in the stream interface, we don't need the applet.handler pointer anymore. That makes the code somewhat cleaner because we know we're dealing with an applet by checking its type instead of checking the pointer is not null.
2011-03-10 05:17:02 -05:00
if (si->target.type == TARG_TYPE_TASK) {
[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 14:57:35 -04:00
/* external handler : kill the task */
[CLEANUP] stream_interface: remove the applet.handler pointer Now that we have the target pointer and type in the stream interface, we don't need the applet.handler pointer anymore. That makes the code somewhat cleaner because we know we're dealing with an applet by checking its type instead of checking the pointer is not null.
2011-03-10 05:17:02 -05:00
task_delete(si->target.ptr.t);
task_free(si->target.ptr.t);
[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 14:57:35 -04:00
}
[MEDIUM] stream-interface: add a ->release callback When a connection is closed on a stream interface, some iohandlers will need to be informed in order to release some resources. This normally happens upon a shutr+shutw. It is the equivalent of the fd_delete() call which is done for real sockets, except that this time we release internal resources. It can also be used with real sockets because it does not cost anything else and might one day be useful.
2010-07-02 05:18:03 -04:00
si->release = NULL;
[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 14:57:35 -04:00
si->owner = NULL;
[CLEANUP] stream_interface: use inline functions to manipulate targets The connection target involves a type and a union of pointers, let's make the code cleaner using simple wrappers.
2011-03-10 08:03:36 -05:00
clear_target(&si->target);
[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 14:57:35 -04:00
}
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 11:12:34 -04:00
/* This callback is used to send a valid PROXY protocol line to a socket being
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
* established. It returns 0 if it fails in a fatal way or needs to poll to go
* further, otherwise it returns non-zero and removes itself from the connection's
* flags (the bit is provided in <flag> by the caller).
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 11:12:34 -04:00
*/
int conn_si_send_proxy(struct connection *conn, unsigned int flag)
{
int fd = conn->t.sock.fd;
struct stream_interface *si = container_of(conn, struct stream_interface, conn);
struct buffer *b = si->ob;
/* we might have been called just after an asynchronous shutw */
if (b->flags & BF_SHUTW)
goto out_error;
/* If we have a PROXY line to send, we'll use this to validate the
* connection, in which case the connection is validated only once
* we've sent the whole proxy line. Otherwise we use connect().
*/
if (si->send_proxy_ofs) {
int ret;
/* The target server expects a PROXY line to be sent first.
* If the send_proxy_ofs is negative, it corresponds to the
* offset to start sending from then end of the proxy string
* (which is recomputed every time since it's constant). If
* it is positive, it means we have to send from the start.
*/
ret = make_proxy_line(trash, trashlen, &b->prod->addr.from, &b->prod->addr.to);
if (!ret)
goto out_error;
if (si->send_proxy_ofs > 0)
si->send_proxy_ofs = -ret; /* first call */
/* we have to send trash from (ret+sp for -sp bytes) */
ret = send(fd, trash + ret + si->send_proxy_ofs, -si->send_proxy_ofs,
(b->flags & BF_OUT_EMPTY) ? 0 : MSG_MORE);
if (ret == 0)
goto out_wait;
if (ret < 0) {
if (errno == EAGAIN)
goto out_wait;
goto out_error;
}
si->send_proxy_ofs += ret; /* becomes zero once complete */
if (si->send_proxy_ofs != 0)
goto out_wait;
/* OK we've sent the whole line, we're connected */
}
/* The FD is ready now, simply return and let the connection handler
* notify upper layers if needed.
*/
if (conn->flags & CO_FL_WAIT_L4_CONN)
conn->flags &= ~CO_FL_WAIT_L4_CONN;
b->flags |= BF_WRITE_NULL;
si->exp = TICK_ETERNITY;
conn->flags &= ~flag;
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
return 1;
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 11:12:34 -04:00
out_error:
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
/* Write error on the file descriptor */
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 11:12:34 -04:00
conn->flags |= CO_FL_ERROR;
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
conn->flags &= ~flag;
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 11:12:34 -04:00
fdtab[fd].ev &= ~FD_POLL_STICKY;
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 11:33:53 -04:00
conn_sock_stop_both(conn);
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
return 0;
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 11:12:34 -04:00
out_wait:
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 11:33:53 -04:00
conn_sock_stop_recv(conn);
conn_sock_poll_send(conn);
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
return 0;
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 11:12:34 -04:00
}
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 06:06:26 -04:00
/* Callback to be used by connection I/O handlers upon completion. It differs from
* the function below in that it is designed to be called by lower layers after I/O
* events have been completed. It will also try to wake the associated task up if
* an important event requires special handling.
*/
void conn_notify_si(struct connection *conn)
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
{
int fd = conn->t.sock.fd;
struct stream_interface *si = container_of(conn, struct stream_interface, conn);
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
MEDIUM: stream_interface: centralize the SI_FL_ERR management It's better to have only stream_sock_update_conn() handle the conversion of the CO_FL_ERROR flag to SI_FL_ERR than having it in each and every I/O callback.
2012-07-23 13:19:51 -04:00
if (conn->flags & CO_FL_ERROR)
si->flags |= SI_FL_ERR;
MAJOR: connection: add a new CO_FL_CONNECTED flag This new flag is used to indicate that the connection was already connected. It can be used by I/O handlers to know that a connection has just completed. It is used by stream_sock_update_conn(), allowing the sock_opt handlers not to manipulate the SI timeout nor the BF_WRITE_NULL flag anymore.
2012-07-23 13:45:44 -04:00
/* check for recent connection establishment */
MAJOR: connection: call data layer handshakes from the handler Handshakes is not called anymore from the data handlers, they're only called from the connection handler when their flag is set. Also, this move has uncovered an issue with the stream interface notifier : it doesn't consider the FD_WAIT_* flags possibly set by the handshake handlers. This will result in a stuck handshake when no data is in the output buffer. In order to cover this, for now we'll perform the EV_FD_SET in the SSL handshake function, but this needs to be addressed separately from the stream interface operations.
2012-07-12 09:32:13 -04:00
if (unlikely(!(conn->flags & (CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN | CO_FL_CONNECTED)))) {
MAJOR: connection: add a new CO_FL_CONNECTED flag This new flag is used to indicate that the connection was already connected. It can be used by I/O handlers to know that a connection has just completed. It is used by stream_sock_update_conn(), allowing the sock_opt handlers not to manipulate the SI timeout nor the BF_WRITE_NULL flag anymore.
2012-07-23 13:45:44 -04:00
si->exp = TICK_ETERNITY;
si->ob->flags |= BF_WRITE_NULL;
}
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
/* process consumer side, only once if possible */
if (fdtab[fd].ev & (FD_POLL_OUT | FD_POLL_ERR)) {
if (si->ob->flags & BF_OUT_EMPTY) {
if (((si->ob->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
(si->state == SI_ST_EST))
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 13:31:45 -04:00
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 11:33:53 -04:00
conn_data_stop_send(conn);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
si->ob->wex = TICK_ETERNITY;
}
if ((si->ob->flags & (BF_FULL|BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == 0)
si->flags |= SI_FL_WAIT_DATA;
if (si->ob->flags & BF_WRITE_ACTIVITY) {
/* update timeouts if we have written something */
if ((si->ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
if (tick_isset(si->ob->wex))
si->ob->wex = tick_add_ifset(now_ms, si->ob->wto);
if (!(si->flags & SI_FL_INDEP_STR))
if (tick_isset(si->ib->rex))
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
if (likely((si->ob->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
(si->ob->prod->flags & SI_FL_WAIT_ROOM)))
si_chk_rcv(si->ob->prod);
}
}
/* process producer side, only once if possible */
if (fdtab[fd].ev & (FD_POLL_IN | FD_POLL_HUP | FD_POLL_ERR)) {
/* We might have some data the consumer is waiting for.
* We can do fast-forwarding, but we avoid doing this for partial
* buffers, because it is very likely that it will be done again
* immediately afterwards once the following data is parsed (eg:
* HTTP chunking).
*/
if (((si->ib->flags & (BF_READ_PARTIAL|BF_OUT_EMPTY)) == BF_READ_PARTIAL) &&
(si->ib->pipe /* always try to send spliced data */ ||
(si->ib->i == 0 && (si->ib->cons->flags & SI_FL_WAIT_DATA)))) {
int last_len = si->ib->pipe ? si->ib->pipe->data : 0;
si_chk_snd(si->ib->cons);
/* check if the consumer has freed some space */
if (!(si->ib->flags & BF_FULL) &&
(!last_len || !si->ib->pipe || si->ib->pipe->data < last_len))
si->flags &= ~SI_FL_WAIT_ROOM;
}
if (si->flags & SI_FL_WAIT_ROOM) {
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 11:33:53 -04:00
conn_data_stop_recv(conn);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
si->ib->rex = TICK_ETERNITY;
}
else if ((si->ib->flags & (BF_SHUTR|BF_READ_PARTIAL|BF_FULL|BF_DONT_READ|BF_READ_NOEXP)) == BF_READ_PARTIAL) {
if (tick_isset(si->ib->rex))
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
}
}
/* wake the task up only when needed */
if (/* changes on the production side */
(si->ib->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
si->state != SI_ST_EST ||
(si->flags & SI_FL_ERR) ||
((si->ib->flags & BF_READ_PARTIAL) &&
(!si->ib->to_forward || si->ib->cons->state != SI_ST_EST)) ||
/* changes on the consumption side */
(si->ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR)) ||
((si->ob->flags & BF_WRITE_ACTIVITY) &&
((si->ob->flags & BF_SHUTW) ||
si->ob->prod->state != SI_ST_EST ||
((si->ob->flags & BF_OUT_EMPTY) && !si->ob->to_forward)))) {
task_wakeup(si->owner, TASK_WOKEN_IO);
}
if (si->ib->flags & BF_READ_ACTIVITY)
si->ib->flags &= ~BF_READ_DONTWAIT;
}
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 11:12:34 -04:00
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 06:06:26 -04:00
/* Updates the timers and flags of a stream interface attached to a connection,
* depending on the buffers' flags. It should only be called once after the
* buffer flags have settled down, and before they are cleared. It doesn't
* harm to call it as often as desired (it just slightly hurts performance).
* It is only meant to be called by upper layers after buffer flags have been
* manipulated by analysers.
*/
void stream_int_update_conn(struct stream_interface *si)
{
struct buffer *ib = si->ib;
struct buffer *ob = si->ob;
if (si->conn.flags & CO_FL_HANDSHAKE) {
/* a handshake is in progress */
si->flags &= ~SI_FL_WAIT_DATA;
return;
}
/* Check if we need to close the read side */
if (!(ib->flags & BF_SHUTR)) {
/* Read not closed, update FD status and timeout for reads */
if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
/* stop reading */
if (!(si->flags & SI_FL_WAIT_ROOM)) {
if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
si->flags |= SI_FL_WAIT_ROOM;
conn_data_stop_recv(&si->conn);
ib->rex = TICK_ETERNITY;
}
}
else {
/* (re)start reading and update timeout. Note: we don't recompute the timeout
* everytime we get here, otherwise it would risk never to expire. We only
* update it if is was not yet set. The stream socket handler will already
* have updated it if there has been a completed I/O.
*/
si->flags &= ~SI_FL_WAIT_ROOM;
conn_data_want_recv(&si->conn);
if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
ib->rex = tick_add_ifset(now_ms, ib->rto);
}
}
/* Check if we need to close the write side */
if (!(ob->flags & BF_SHUTW)) {
/* Write not closed, update FD status and timeout for writes */
if (ob->flags & BF_OUT_EMPTY) {
/* stop writing */
if (!(si->flags & SI_FL_WAIT_DATA)) {
if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
si->flags |= SI_FL_WAIT_DATA;
conn_data_stop_send(&si->conn);
ob->wex = TICK_ETERNITY;
}
}
else {
/* (re)start writing and update timeout. Note: we don't recompute the timeout
* everytime we get here, otherwise it would risk never to expire. We only
* update it if is was not yet set. The stream socket handler will already
* have updated it if there has been a completed I/O.
*/
si->flags &= ~SI_FL_WAIT_DATA;
conn_data_want_send(&si->conn);
if (!tick_isset(ob->wex)) {
ob->wex = tick_add_ifset(now_ms, ob->wto);
if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
/* Note: depending on the protocol, we don't know if we're waiting
* for incoming data or not. So in order to prevent the socket from
* expiring read timeouts during writes, we refresh the read timeout,
* except if it was already infinite or if we have explicitly setup
* independent streams.
*/
ib->rex = tick_add_ifset(now_ms, ib->rto);
}
}
}
}
}
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
/* This function is used for inter-stream-interface calls. It is called by the
* consumer to inform the producer side that it may be interested in checking
* for free space in the buffer. Note that it intentionally does not update
* timeouts, so that we can still check them later at wake-up. This function is
* dedicated to connection-based stream interfaces.
*/
void stream_int_chk_rcv_conn(struct stream_interface *si)
{
struct buffer *ib = si->ib;
if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
return;
if (si->conn.flags & CO_FL_HANDSHAKE) {
/* a handshake is in progress */
return;
}
if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
/* stop reading */
if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
si->flags |= SI_FL_WAIT_ROOM;
conn_data_stop_recv(&si->conn);
}
else {
/* (re)start reading */
si->flags &= ~SI_FL_WAIT_ROOM;
conn_data_want_recv(&si->conn);
}
}
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
/* This function is used for inter-stream-interface calls. It is called by the
* producer to inform the consumer side that it may be interested in checking
* for data in the buffer. Note that it intentionally does not update timeouts,
* so that we can still check them later at wake-up.
*/
void stream_int_chk_snd_conn(struct stream_interface *si)
{
struct buffer *ob = si->ob;
if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
return;
/* handshake running on producer */
if (si->conn.flags & CO_FL_HANDSHAKE) {
/* a handshake is in progress */
si->flags &= ~SI_FL_WAIT_DATA;
return;
}
if (unlikely((ob->flags & BF_OUT_EMPTY))) /* called with nothing to send ! */
return;
if (!ob->pipe && /* spliced data wants to be forwarded ASAP */
(!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
(fdtab[si_fd(si)].ev & FD_POLL_OUT))) /* we'll be called anyway */
return;
if (conn_data_snd_buf(&si->conn) < 0) {
/* Write error on the file descriptor. We mark the FD as STERROR so
* that we don't use it anymore and we notify the task.
*/
fdtab[si_fd(si)].ev &= ~FD_POLL_STICKY;
conn_data_stop_both(&si->conn);
si->flags |= SI_FL_ERR;
si->conn.flags |= CO_FL_ERROR;
goto out_wakeup;
}
/* OK, so now we know that some data might have been sent, and that we may
* have to poll first. We have to do that too if the buffer is not empty.
*/
if (ob->flags & BF_OUT_EMPTY) {
/* the connection is established but we can't write. Either the
* buffer is empty, or we just refrain from sending because the
* ->o limit was reached. Maybe we just wrote the last
* chunk and need to close.
*/
if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
(BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
(si->state == SI_ST_EST)) {
si_shutw(si);
goto out_wakeup;
}
if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
si->flags |= SI_FL_WAIT_DATA;
ob->wex = TICK_ETERNITY;
}
else {
/* Otherwise there are remaining data to be sent in the buffer,
* which means we have to poll before doing so.
*/
conn_data_want_send(&si->conn);
si->flags &= ~SI_FL_WAIT_DATA;
if (!tick_isset(ob->wex))
ob->wex = tick_add_ifset(now_ms, ob->wto);
}
if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
/* update timeout if we have written something */
if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
ob->wex = tick_add_ifset(now_ms, ob->wto);
if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
/* Note: to prevent the client from expiring read timeouts
* during writes, we refresh it. We only do this if the
* interface is not configured for "independent streams",
* because for some applications it's better not to do this,
* for instance when continuously exchanging small amounts
* of data which can full the socket buffers long before a
* write timeout is detected.
*/
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
}
}
/* in case of special condition (error, shutdown, end of write...), we
* have to notify the task.
*/
if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
si->state != SI_ST_EST)) {
out_wakeup:
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
}
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 09:09:53 -04:00
/*
* This is the callback which is called by the connection layer to send data
* from the buffer to the connection. It iterates over the data layer's snd_buf
* function.
*/
void si_conn_send_cb(struct connection *conn)
{
struct stream_interface *si = container_of(conn, struct stream_interface, conn);
struct buffer *b = si->ob;
if (conn->flags & CO_FL_ERROR)
goto out_error;
if (si->conn.flags & CO_FL_HANDSHAKE)
/* a handshake was requested */
return;
/* we might have been called just after an asynchronous shutw */
if (b->flags & BF_SHUTW)
return;
/* OK there are data waiting to be sent */
if (conn_data_snd_buf(conn) < 0)
goto out_error;
/* OK all done */
return;
out_error:
/* Write error on the connection, report the error and stop I/O */
conn->flags |= CO_FL_ERROR;
conn_data_stop_both(conn);
}
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04: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 00:26:53 -05:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink