1berry/haproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MAJOR: session: detach the connections from the stream interfaces

Browse Source 
We will need to be able to switch server connections on a session and
to keep idle connections. In order to achieve this, the preliminary
requirement is that the connections can survive the session and be
detached from them.

Right now they're still allocated at exactly the same place, so when
there is a session, there are always 2 connections. We could soon
improve on this by allocating the outgoing connection only during a
connect().

This current patch touches a lot of code and intentionally does not
change any functionnality. Performance tests show no regression (even
a very minor improvement). The doc has not yet been updated.
This commit is contained in:
Willy Tarreau 2012-10-26 20:10:28 +02:00
parent c919dc66a3
commit f2943dccd0
15 changed files with 404 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/proto/connection.h
View File

@ -23,9 +23,15 @@
#define _PROTO_CONNECTION_H #define _PROTO_CONNECTION_H
#include <common/config.h> #include <common/config.h>
#include <common/memory.h>
#include <types/connection.h> #include <types/connection.h>
#include <types/listener.h> #include <types/listener.h>
extern struct pool_head *pool2_connection;
/* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_connection();
/* I/O callback for fd-based connections. It calls the read/write handlers /* I/O callback for fd-based connections. It calls the read/write handlers
* provided by the connection's sock_ops. Returns 0. * provided by the connection's sock_ops. Returns 0.
*/ */

24
include/proto/stream_interface.h
View File

@ -53,50 +53,50 @@ void stream_int_unregister_handler(struct stream_interface *si);
static inline const struct protocol *si_ctrl(struct stream_interface *si) static inline const struct protocol *si_ctrl(struct stream_interface *si)
{ {
return si->conn.ctrl; return si->conn->ctrl;
} }
static inline int si_fd(struct stream_interface *si) static inline int si_fd(struct stream_interface *si)
{ {
return si->conn.t.sock.fd; return si->conn->t.sock.fd;
} }
static inline void si_prepare_conn(struct stream_interface *si, const struct protocol *ctrl, const struct xprt_ops *xprt) static inline void si_prepare_conn(struct stream_interface *si, const struct protocol *ctrl, const struct xprt_ops *xprt)
{ {
si->ops = &si_conn_ops; si->ops = &si_conn_ops;
conn_prepare(&si->conn, &si_conn_cb, ctrl, xprt, si); conn_prepare(si->conn, &si_conn_cb, ctrl, xprt, si);
} }
static inline void si_takeover_conn(struct stream_interface *si, const struct protocol *ctrl, const struct xprt_ops *xprt) static inline void si_takeover_conn(struct stream_interface *si, const struct protocol *ctrl, const struct xprt_ops *xprt)
{ {
si->ops = &si_conn_ops; si->ops = &si_conn_ops;
conn_assign(&si->conn, &si_conn_cb, ctrl, xprt, si); conn_assign(si->conn, &si_conn_cb, ctrl, xprt, si);
} }
static inline void si_prepare_embedded(struct stream_interface *si) static inline void si_prepare_embedded(struct stream_interface *si)
{ {
si->ops = &si_embedded_ops; si->ops = &si_embedded_ops;
conn_prepare(&si->conn, NULL, NULL, NULL, si); conn_prepare(si->conn, NULL, NULL, NULL, si);
} }
static inline void si_prepare_task(struct stream_interface *si) static inline void si_prepare_task(struct stream_interface *si)
{ {
si->ops = &si_task_ops; si->ops = &si_task_ops;
conn_prepare(&si->conn, NULL, NULL, NULL, si); conn_prepare(si->conn, NULL, NULL, NULL, si);
} }
/* Sends a shutr to the connection using the data layer */ /* Sends a shutr to the connection using the data layer */
static inline void si_shutr(struct stream_interface *si) static inline void si_shutr(struct stream_interface *si)
{ {
if (stream_int_shutr(si)) if (stream_int_shutr(si))
conn_data_stop_recv(&si->conn); conn_data_stop_recv(si->conn);
} }
/* Sends a shutw to the connection using the data layer */ /* Sends a shutw to the connection using the data layer */
static inline void si_shutw(struct stream_interface *si) static inline void si_shutw(struct stream_interface *si)
{ {
if (stream_int_shutw(si)) if (stream_int_shutw(si))
conn_data_stop_send(&si->conn); conn_data_stop_send(si->conn);
} }
/* Calls the data state update on the stream interfaace */ /* Calls the data state update on the stream interfaace */
@ -125,20 +125,20 @@ static inline int si_connect(struct stream_interface *si)
if (unlikely(!si_ctrl(si) || !si_ctrl(si)->connect)) if (unlikely(!si_ctrl(si) || !si_ctrl(si)->connect))
return SN_ERR_INTERNAL; return SN_ERR_INTERNAL;
ret = si_ctrl(si)->connect(&si->conn, !channel_is_empty(si->ob)); ret = si_ctrl(si)->connect(si->conn, !channel_is_empty(si->ob));
if (ret != SN_ERR_NONE) if (ret != SN_ERR_NONE)
return ret; return ret;
/* needs src ip/port for logging */ /* needs src ip/port for logging */
if (si->flags & SI_FL_SRC_ADDR) if (si->flags & SI_FL_SRC_ADDR)
conn_get_from_addr(&si->conn); conn_get_from_addr(si->conn);
/* Prepare to send a few handshakes related to the on-wire protocol. */ /* Prepare to send a few handshakes related to the on-wire protocol. */
if (si->send_proxy_ofs) if (si->send_proxy_ofs)
si->conn.flags |= CO_FL_SI_SEND_PROXY; si->conn->flags |= CO_FL_SI_SEND_PROXY;
/* we need to be notified about connection establishment */ /* we need to be notified about connection establishment */
si->conn.flags |= CO_FL_WAKE_DATA; si->conn->flags |= CO_FL_WAKE_DATA;
/* we're in the process of establishing a connection */ /* we're in the process of establishing a connection */
si->state = SI_ST_CON; si->state = SI_ST_CON;

2
include/types/stream_interface.h
View File

@ -108,7 +108,7 @@ struct stream_interface {
unsigned int err_type; /* first error detected, one of SI_ET_* */ unsigned int err_type; /* first error detected, one of SI_ET_* */
void *err_loc; /* commonly the server, NULL when SI_ET_NONE */ void *err_loc; /* commonly the server, NULL when SI_ET_NONE */
struct connection conn; /* descriptor for a connection */ struct connection *conn; /* descriptor for a connection */
struct si_ops *ops; /* general operations at the stream interface layer */ struct si_ops *ops; /* general operations at the stream interface layer */
void (*release)(struct stream_interface *); /* handler to call after the last close() */ void (*release)(struct stream_interface *); /* handler to call after the last close() */

74
src/backend.c
View File

@ -547,14 +547,14 @@ int assign_server(struct session *s)
switch (s->be->lbprm.algo & BE_LB_PARM) { switch (s->be->lbprm.algo & BE_LB_PARM) {
case BE_LB_HASH_SRC: case BE_LB_HASH_SRC:
if (s->req->prod->conn.addr.from.ss_family == AF_INET) { if (s->req->prod->conn->addr.from.ss_family == AF_INET) {
srv = get_server_sh(s->be, srv = get_server_sh(s->be,
(void *)&((struct sockaddr_in *)&s->req->prod->conn.addr.from)->sin_addr, (void *)&((struct sockaddr_in *)&s->req->prod->conn->addr.from)->sin_addr,
4); 4);
} }
else if (s->req->prod->conn.addr.from.ss_family == AF_INET6) { else if (s->req->prod->conn->addr.from.ss_family == AF_INET6) {
srv = get_server_sh(s->be, srv = get_server_sh(s->be,
(void *)&((struct sockaddr_in6 *)&s->req->prod->conn.addr.from)->sin6_addr, (void *)&((struct sockaddr_in6 *)&s->req->prod->conn->addr.from)->sin6_addr,
16); 16);
} }
else { else {
@ -637,7 +637,7 @@ int assign_server(struct session *s)
set_target_proxy(&s->target, s->be); set_target_proxy(&s->target, s->be);
} }
else if ((s->be->options & PR_O_HTTP_PROXY) && else if ((s->be->options & PR_O_HTTP_PROXY) &&
is_addr(&s->req->cons->conn.addr.to)) { is_addr(&s->req->cons->conn->addr.to)) {
/* in proxy mode, we need a valid destination address */ /* in proxy mode, we need a valid destination address */
set_target_proxy(&s->target, s->be); set_target_proxy(&s->target, s->be);
} }
@ -691,20 +691,20 @@ int assign_server_address(struct session *s)
if (!(s->flags & SN_ASSIGNED)) if (!(s->flags & SN_ASSIGNED))
return SRV_STATUS_INTERNAL; return SRV_STATUS_INTERNAL;
s->req->cons->conn.addr.to = target_srv(&s->target)->addr; s->req->cons->conn->addr.to = target_srv(&s->target)->addr;
if (!is_addr(&s->req->cons->conn.addr.to)) { if (!is_addr(&s->req->cons->conn->addr.to)) {
/* if the server has no address, we use the same address /* if the server has no address, we use the same address
* the client asked, which is handy for remapping ports * the client asked, which is handy for remapping ports
* locally on multiple addresses at once. * locally on multiple addresses at once.
*/ */
if (!(s->be->options & PR_O_TRANSP)) if (!(s->be->options & PR_O_TRANSP))
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
if (s->req->prod->conn.addr.to.ss_family == AF_INET) { if (s->req->prod->conn->addr.to.ss_family == AF_INET) {
((struct sockaddr_in *)&s->req->cons->conn.addr.to)->sin_addr = ((struct sockaddr_in *)&s->req->prod->conn.addr.to)->sin_addr; ((struct sockaddr_in *)&s->req->cons->conn->addr.to)->sin_addr = ((struct sockaddr_in *)&s->req->prod->conn->addr.to)->sin_addr;
} else if (s->req->prod->conn.addr.to.ss_family == AF_INET6) { } else if (s->req->prod->conn->addr.to.ss_family == AF_INET6) {
((struct sockaddr_in6 *)&s->req->cons->conn.addr.to)->sin6_addr = ((struct sockaddr_in6 *)&s->req->prod->conn.addr.to)->sin6_addr; ((struct sockaddr_in6 *)&s->req->cons->conn->addr.to)->sin6_addr = ((struct sockaddr_in6 *)&s->req->prod->conn->addr.to)->sin6_addr;
} }
} }
@ -714,26 +714,26 @@ int assign_server_address(struct session *s)
int base_port; int base_port;
if (!(s->be->options & PR_O_TRANSP)) if (!(s->be->options & PR_O_TRANSP))
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
/* First, retrieve the port from the incoming connection */ /* First, retrieve the port from the incoming connection */
base_port = get_host_port(&s->req->prod->conn.addr.to); base_port = get_host_port(&s->req->prod->conn->addr.to);
/* Second, assign the outgoing connection's port */ /* Second, assign the outgoing connection's port */
base_port += get_host_port(&s->req->cons->conn.addr.to); base_port += get_host_port(&s->req->cons->conn->addr.to);
set_host_port(&s->req->cons->conn.addr.to, base_port); set_host_port(&s->req->cons->conn->addr.to, base_port);
} }
} }
else if (s->be->options & PR_O_DISPATCH) { else if (s->be->options & PR_O_DISPATCH) {
/* connect to the defined dispatch addr */ /* connect to the defined dispatch addr */
s->req->cons->conn.addr.to = s->be->dispatch_addr; s->req->cons->conn->addr.to = s->be->dispatch_addr;
} }
else if (s->be->options & PR_O_TRANSP) { else if (s->be->options & PR_O_TRANSP) {
/* in transparent mode, use the original dest addr if no dispatch specified */ /* in transparent mode, use the original dest addr if no dispatch specified */
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
if (s->req->prod->conn.addr.to.ss_family == AF_INET || s->req->prod->conn.addr.to.ss_family == AF_INET6) { if (s->req->prod->conn->addr.to.ss_family == AF_INET || s->req->prod->conn->addr.to.ss_family == AF_INET6) {
memcpy(&s->req->cons->conn.addr.to, &s->req->prod->conn.addr.to, MIN(sizeof(s->req->cons->conn.addr.to), sizeof(s->req->prod->conn.addr.to))); memcpy(&s->req->cons->conn->addr.to, &s->req->prod->conn->addr.to, MIN(sizeof(s->req->cons->conn->addr.to), sizeof(s->req->prod->conn->addr.to)));
} }
/* when we support IPv6 on the backend, we may add other tests */ /* when we support IPv6 on the backend, we may add other tests */
//qfprintf(stderr, "Cannot get original server address.\n"); //qfprintf(stderr, "Cannot get original server address.\n");
@ -887,12 +887,12 @@ static void assign_tproxy_address(struct session *s)
if (srv && srv->state & SRV_BIND_SRC) { if (srv && srv->state & SRV_BIND_SRC) {
switch (srv->state & SRV_TPROXY_MASK) { switch (srv->state & SRV_TPROXY_MASK) {
case SRV_TPROXY_ADDR: case SRV_TPROXY_ADDR:
s->req->cons->conn.addr.from = srv->tproxy_addr; s->req->cons->conn->addr.from = srv->tproxy_addr;
break; break;
case SRV_TPROXY_CLI: case SRV_TPROXY_CLI:
case SRV_TPROXY_CIP: case SRV_TPROXY_CIP:
/* FIXME: what can we do if the client connects in IPv6 or unix socket ? */ /* FIXME: what can we do if the client connects in IPv6 or unix socket ? */
s->req->cons->conn.addr.from = s->req->prod->conn.addr.from; s->req->cons->conn->addr.from = s->req->prod->conn->addr.from;
break; break;
case SRV_TPROXY_DYN: case SRV_TPROXY_DYN:
if (srv->bind_hdr_occ) { if (srv->bind_hdr_occ) {
@ -901,32 +901,32 @@ static void assign_tproxy_address(struct session *s)
int rewind; int rewind;
/* bind to the IP in a header */ /* bind to the IP in a header */
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_family = AF_INET; ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_family = AF_INET;
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_port = 0; ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_port = 0;
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_addr.s_addr = 0; ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_addr.s_addr = 0;
b_rew(s->req->buf, rewind = s->req->buf->o); b_rew(s->req->buf, rewind = s->req->buf->o);
if (http_get_hdr(&s->txn.req, srv->bind_hdr_name, srv->bind_hdr_len, if (http_get_hdr(&s->txn.req, srv->bind_hdr_name, srv->bind_hdr_len,
&s->txn.hdr_idx, srv->bind_hdr_occ, NULL, &vptr, &vlen)) { &s->txn.hdr_idx, srv->bind_hdr_occ, NULL, &vptr, &vlen)) {
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_addr.s_addr = ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_addr.s_addr =
htonl(inetaddr_host_lim(vptr, vptr + vlen)); htonl(inetaddr_host_lim(vptr, vptr + vlen));
} }
b_adv(s->req->buf, rewind); b_adv(s->req->buf, rewind);
} }
break; break;
default: default:
memset(&s->req->cons->conn.addr.from, 0, sizeof(s->req->cons->conn.addr.from)); memset(&s->req->cons->conn->addr.from, 0, sizeof(s->req->cons->conn->addr.from));
} }
} }
else if (s->be->options & PR_O_BIND_SRC) { else if (s->be->options & PR_O_BIND_SRC) {
switch (s->be->options & PR_O_TPXY_MASK) { switch (s->be->options & PR_O_TPXY_MASK) {
case PR_O_TPXY_ADDR: case PR_O_TPXY_ADDR:
s->req->cons->conn.addr.from = s->be->tproxy_addr; s->req->cons->conn->addr.from = s->be->tproxy_addr;
break; break;
case PR_O_TPXY_CLI: case PR_O_TPXY_CLI:
case PR_O_TPXY_CIP: case PR_O_TPXY_CIP:
/* FIXME: what can we do if the client connects in IPv6 or socket unix? */ /* FIXME: what can we do if the client connects in IPv6 or socket unix? */
s->req->cons->conn.addr.from = s->req->prod->conn.addr.from; s->req->cons->conn->addr.from = s->req->prod->conn->addr.from;
break; break;
case PR_O_TPXY_DYN: case PR_O_TPXY_DYN:
if (s->be->bind_hdr_occ) { if (s->be->bind_hdr_occ) {
@ -935,21 +935,21 @@ static void assign_tproxy_address(struct session *s)
int rewind; int rewind;
/* bind to the IP in a header */ /* bind to the IP in a header */
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_family = AF_INET; ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_family = AF_INET;
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_port = 0; ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_port = 0;
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_addr.s_addr = 0; ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_addr.s_addr = 0;
b_rew(s->req->buf, rewind = s->req->buf->o); b_rew(s->req->buf, rewind = s->req->buf->o);
if (http_get_hdr(&s->txn.req, s->be->bind_hdr_name, s->be->bind_hdr_len, if (http_get_hdr(&s->txn.req, s->be->bind_hdr_name, s->be->bind_hdr_len,
&s->txn.hdr_idx, s->be->bind_hdr_occ, NULL, &vptr, &vlen)) { &s->txn.hdr_idx, s->be->bind_hdr_occ, NULL, &vptr, &vlen)) {
((struct sockaddr_in *)&s->req->cons->conn.addr.from)->sin_addr.s_addr = ((struct sockaddr_in *)&s->req->cons->conn->addr.from)->sin_addr.s_addr =
htonl(inetaddr_host_lim(vptr, vptr + vlen)); htonl(inetaddr_host_lim(vptr, vptr + vlen));
} }
b_adv(s->req->buf, rewind); b_adv(s->req->buf, rewind);
} }
break; break;
default: default:
memset(&s->req->cons->conn.addr.from, 0, sizeof(s->req->cons->conn.addr.from)); memset(&s->req->cons->conn->addr.from, 0, sizeof(s->req->cons->conn->addr.from));
} }
} }
#endif #endif
@ -981,7 +981,7 @@ int connect_server(struct session *s)
} }
/* the target was only on the session, assign it to the SI now */ /* the target was only on the session, assign it to the SI now */
copy_target(&s->req->cons->conn.target, &s->target); copy_target(&s->req->cons->conn->target, &s->target);
/* set the correct protocol on the output stream interface */ /* set the correct protocol on the output stream interface */
if (s->target.type == TARG_TYPE_SERVER) { if (s->target.type == TARG_TYPE_SERVER) {
@ -989,7 +989,7 @@ int connect_server(struct session *s)
} }
else if (s->target.type == TARG_TYPE_PROXY) { else if (s->target.type == TARG_TYPE_PROXY) {
/* proxies exclusively run on raw_sock right now */ /* proxies exclusively run on raw_sock right now */
si_prepare_conn(s->req->cons, protocol_by_family(s->req->cons->conn.addr.to.ss_family), &raw_sock); si_prepare_conn(s->req->cons, protocol_by_family(s->req->cons->conn->addr.to.ss_family), &raw_sock);
if (!si_ctrl(s->req->cons)) if (!si_ctrl(s->req->cons))
return SN_ERR_INTERNAL; return SN_ERR_INTERNAL;
} }
@ -1000,7 +1000,7 @@ int connect_server(struct session *s)
s->req->cons->send_proxy_ofs = 0; s->req->cons->send_proxy_ofs = 0;
if (s->target.type == TARG_TYPE_SERVER && (s->target.ptr.s->state & SRV_SEND_PROXY)) { if (s->target.type == TARG_TYPE_SERVER && (s->target.ptr.s->state & SRV_SEND_PROXY)) {
s->req->cons->send_proxy_ofs = 1; /* must compute size */ s->req->cons->send_proxy_ofs = 1; /* must compute size */
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
} }
assign_tproxy_address(s); assign_tproxy_address(s);

9
src/connection.c
View File

@ -26,6 +26,15 @@
#include <proto/ssl_sock.h> #include <proto/ssl_sock.h>
#endif #endif
struct pool_head *pool2_connection;
/* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_connection()
{
pool2_connection = create_pool("connection", sizeof (struct connection), MEM_F_SHARED);
return pool2_connection != NULL;
}
/* I/O callback for fd-based connections. It calls the read/write handlers /* I/O callback for fd-based connections. It calls the read/write handlers
* provided by the connection's sock_ops, which must be valid. It returns 0. * provided by the connection's sock_ops, which must be valid. It returns 0.
*/ */

118
src/dumpstats.c
View File

@ -125,8 +125,8 @@ static int stats_accept(struct session *s)
{ {
/* we have a dedicated I/O handler for the stats */ /* we have a dedicated I/O handler for the stats */
stream_int_register_handler(&s->si[1], &cli_applet); stream_int_register_handler(&s->si[1], &cli_applet);
copy_target(&s->target, &s->si[1].conn.target); // for logging only copy_target(&s->target, &s->si[1].conn->target); // for logging only
s->si[1].conn.xprt_ctx = s; s->si[1].conn->xprt_ctx = s;
s->si[1].applet.st1 = 0; s->si[1].applet.st1 = 0;
s->si[1].applet.st0 = STAT_CLI_INIT; s->si[1].applet.st0 = STAT_CLI_INIT;
@ -431,7 +431,7 @@ static int dump_binary(struct chunk *out, const char *buf, int bsize)
static int stats_dump_table_head_to_buffer(struct chunk *msg, struct stream_interface *si, static int stats_dump_table_head_to_buffer(struct chunk *msg, struct stream_interface *si,
struct proxy *proxy, struct proxy *target) struct proxy *proxy, struct proxy *target)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
chunk_printf(msg, "# table: %s, type: %s, size:%d, used:%d\n", chunk_printf(msg, "# table: %s, type: %s, size:%d, used:%d\n",
proxy->id, stktable_types[proxy->table.type].kw, proxy->table.size, proxy->table.current); proxy->id, stktable_types[proxy->table.type].kw, proxy->table.size, proxy->table.current);
@ -520,7 +520,7 @@ static int stats_dump_table_entry_to_buffer(struct chunk *msg, struct stream_int
static void stats_sock_table_key_request(struct stream_interface *si, char **args, int action) static void stats_sock_table_key_request(struct stream_interface *si, char **args, int action)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
struct proxy *px = si->applet.ctx.table.target; struct proxy *px = si->applet.ctx.table.target;
struct stksess *ts; struct stksess *ts;
uint32_t uint32_key; uint32_t uint32_key;
@ -723,7 +723,7 @@ static void stats_sock_table_data_request(struct stream_interface *si, char **ar
static void stats_sock_table_request(struct stream_interface *si, char **args, int action) static void stats_sock_table_request(struct stream_interface *si, char **args, int action)
{ {
si->applet.ctx.table.data_type = -1; si->applet.ctx.table.data_type = -1;
si->conn.xprt_st = STAT_ST_INIT; si->conn->xprt_st = STAT_ST_INIT;
si->applet.ctx.table.target = NULL; si->applet.ctx.table.target = NULL;
si->applet.ctx.table.proxy = NULL; si->applet.ctx.table.proxy = NULL;
si->applet.ctx.table.entry = NULL; si->applet.ctx.table.entry = NULL;
@ -849,7 +849,7 @@ static struct server *expect_server_admin(struct session *s, struct stream_inter
*/ */
static int stats_sock_parse_request(struct stream_interface *si, char *line) static int stats_sock_parse_request(struct stream_interface *si, char *line)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
char *args[MAX_STATS_ARGS + 1]; char *args[MAX_STATS_ARGS + 1];
int arg; int arg;
@ -888,17 +888,17 @@ static int stats_sock_parse_request(struct stream_interface *si, char *line)
si->applet.ctx.stats.flags |= STAT_SHOW_STAT; si->applet.ctx.stats.flags |= STAT_SHOW_STAT;
si->applet.ctx.stats.flags |= STAT_FMT_CSV; si->applet.ctx.stats.flags |= STAT_FMT_CSV;
si->conn.xprt_st = STAT_ST_INIT; si->conn->xprt_st = STAT_ST_INIT;
si->applet.st0 = STAT_CLI_O_INFO; // stats_dump_raw_to_buffer si->applet.st0 = STAT_CLI_O_INFO; // stats_dump_raw_to_buffer
} }
else if (strcmp(args[1], "info") == 0) { else if (strcmp(args[1], "info") == 0) {
si->applet.ctx.stats.flags |= STAT_SHOW_INFO; si->applet.ctx.stats.flags |= STAT_SHOW_INFO;
si->applet.ctx.stats.flags |= STAT_FMT_CSV; si->applet.ctx.stats.flags |= STAT_FMT_CSV;
si->conn.xprt_st = STAT_ST_INIT; si->conn->xprt_st = STAT_ST_INIT;
si->applet.st0 = STAT_CLI_O_INFO; // stats_dump_raw_to_buffer si->applet.st0 = STAT_CLI_O_INFO; // stats_dump_raw_to_buffer
} }
else if (strcmp(args[1], "sess") == 0) { else if (strcmp(args[1], "sess") == 0) {
si->conn.xprt_st = STAT_ST_INIT; si->conn->xprt_st = STAT_ST_INIT;
if (s->listener->bind_conf->level < ACCESS_LVL_OPER) { if (s->listener->bind_conf->level < ACCESS_LVL_OPER) {
si->applet.ctx.cli.msg = stats_permission_denied_msg; si->applet.ctx.cli.msg = stats_permission_denied_msg;
si->applet.st0 = STAT_CLI_PRINT; si->applet.st0 = STAT_CLI_PRINT;
@ -923,7 +923,7 @@ static int stats_sock_parse_request(struct stream_interface *si, char *line)
else else
si->applet.ctx.errors.iid = -1; si->applet.ctx.errors.iid = -1;
si->applet.ctx.errors.px = NULL; si->applet.ctx.errors.px = NULL;
si->conn.xprt_st = STAT_ST_INIT; si->conn->xprt_st = STAT_ST_INIT;
si->applet.st0 = STAT_CLI_O_ERR; // stats_dump_errors_to_buffer si->applet.st0 = STAT_CLI_O_ERR; // stats_dump_errors_to_buffer
} }
else if (strcmp(args[1], "table") == 0) { else if (strcmp(args[1], "table") == 0) {
@ -1670,10 +1670,10 @@ static int stats_dump_raw_to_buffer(struct stream_interface *si)
chunk_init(&msg, trash, global.tune.bufsize); chunk_init(&msg, trash, global.tune.bufsize);
switch (si->conn.xprt_st) { switch (si->conn->xprt_st) {
case STAT_ST_INIT: case STAT_ST_INIT:
/* the function had not been called yet */ /* the function had not been called yet */
si->conn.xprt_st = STAT_ST_HEAD; si->conn->xprt_st = STAT_ST_HEAD;
/* fall through */ /* fall through */
case STAT_ST_HEAD: case STAT_ST_HEAD:
@ -1683,7 +1683,7 @@ static int stats_dump_raw_to_buffer(struct stream_interface *si)
return 0; return 0;
} }
si->conn.xprt_st = STAT_ST_INFO; si->conn->xprt_st = STAT_ST_INFO;
/* fall through */ /* fall through */
case STAT_ST_INFO: case STAT_ST_INFO:
@ -1736,7 +1736,7 @@ static int stats_dump_raw_to_buffer(struct stream_interface *si)
si->applet.ctx.stats.px = proxy; si->applet.ctx.stats.px = proxy;
si->applet.ctx.stats.px_st = STAT_PX_ST_INIT; si->applet.ctx.stats.px_st = STAT_PX_ST_INIT;
si->applet.ctx.stats.sv = NULL; si->applet.ctx.stats.sv = NULL;
si->conn.xprt_st = STAT_ST_LIST; si->conn->xprt_st = STAT_ST_LIST;
/* fall through */ /* fall through */
case STAT_ST_LIST: case STAT_ST_LIST:
@ -1757,11 +1757,11 @@ static int stats_dump_raw_to_buffer(struct stream_interface *si)
/* here, we just have reached the last proxy */ /* here, we just have reached the last proxy */
} }
si->conn.xprt_st = STAT_ST_END; si->conn->xprt_st = STAT_ST_END;
/* fall through */ /* fall through */
case STAT_ST_END: case STAT_ST_END:
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
/* fall through */ /* fall through */
case STAT_ST_FIN: case STAT_ST_FIN:
@ -1769,7 +1769,7 @@ static int stats_dump_raw_to_buffer(struct stream_interface *si)
default: default:
/* unknown state ! */ /* unknown state ! */
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
return 1; return 1;
} }
} }
@ -1781,12 +1781,12 @@ static int stats_dump_raw_to_buffer(struct stream_interface *si)
*/ */
static int stats_http_redir(struct stream_interface *si, struct uri_auth *uri) static int stats_http_redir(struct stream_interface *si, struct uri_auth *uri)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
struct chunk msg; struct chunk msg;
chunk_init(&msg, trash, global.tune.bufsize); chunk_init(&msg, trash, global.tune.bufsize);
switch (si->conn.xprt_st) { switch (si->conn->xprt_st) {
case STAT_ST_INIT: case STAT_ST_INIT:
chunk_printf(&msg, chunk_printf(&msg,
"HTTP/1.0 303 See Other\r\n" "HTTP/1.0 303 See Other\r\n"
@ -1812,7 +1812,7 @@ static int stats_http_redir(struct stream_interface *si, struct uri_auth *uri)
if (!(s->flags & SN_FINST_MASK)) if (!(s->flags & SN_FINST_MASK))
s->flags |= SN_FINST_R; s->flags |= SN_FINST_R;
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
return 1; return 1;
} }
return 1; return 1;
@ -1826,7 +1826,7 @@ static int stats_http_redir(struct stream_interface *si, struct uri_auth *uri)
*/ */
static void http_stats_io_handler(struct stream_interface *si) static void http_stats_io_handler(struct stream_interface *si)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
struct channel *req = si->ob; struct channel *req = si->ob;
struct channel *res = si->ib; struct channel *res = si->ib;
@ -1882,7 +1882,7 @@ static void http_stats_io_handler(struct stream_interface *si)
*/ */
static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri) static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
struct channel *rep = si->ib; struct channel *rep = si->ib;
struct proxy *px; struct proxy *px;
struct chunk msg; struct chunk msg;
@ -1890,7 +1890,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
chunk_init(&msg, trash, global.tune.bufsize); chunk_init(&msg, trash, global.tune.bufsize);
switch (si->conn.xprt_st) { switch (si->conn->xprt_st) {
case STAT_ST_INIT: case STAT_ST_INIT:
chunk_printf(&msg, chunk_printf(&msg,
"HTTP/1.0 200 OK\r\n" "HTTP/1.0 200 OK\r\n"
@ -1916,11 +1916,11 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
if (s->txn.meth == HTTP_METH_HEAD) { if (s->txn.meth == HTTP_METH_HEAD) {
/* that's all we return in case of HEAD request */ /* that's all we return in case of HEAD request */
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
return 1; return 1;
} }
si->conn.xprt_st = STAT_ST_HEAD; /* let's start producing data */ si->conn->xprt_st = STAT_ST_HEAD; /* let's start producing data */
/* fall through */ /* fall through */
case STAT_ST_HEAD: case STAT_ST_HEAD:
@ -2024,7 +2024,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
if (bi_putchk(rep, &msg) == -1) if (bi_putchk(rep, &msg) == -1)
return 0; return 0;
si->conn.xprt_st = STAT_ST_INFO; si->conn->xprt_st = STAT_ST_INFO;
/* fall through */ /* fall through */
case STAT_ST_INFO: case STAT_ST_INFO:
@ -2202,7 +2202,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
si->applet.ctx.stats.px = proxy; si->applet.ctx.stats.px = proxy;
si->applet.ctx.stats.px_st = STAT_PX_ST_INIT; si->applet.ctx.stats.px_st = STAT_PX_ST_INIT;
si->conn.xprt_st = STAT_ST_LIST; si->conn->xprt_st = STAT_ST_LIST;
/* fall through */ /* fall through */
case STAT_ST_LIST: case STAT_ST_LIST:
@ -2221,7 +2221,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
} }
/* here, we just have reached the last proxy */ /* here, we just have reached the last proxy */
si->conn.xprt_st = STAT_ST_END; si->conn->xprt_st = STAT_ST_END;
/* fall through */ /* fall through */
case STAT_ST_END: case STAT_ST_END:
@ -2231,7 +2231,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
return 0; return 0;
} }
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
/* fall through */ /* fall through */
case STAT_ST_FIN: case STAT_ST_FIN:
@ -2239,7 +2239,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
default: default:
/* unknown state ! */ /* unknown state ! */
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
return -1; return -1;
} }
} }
@ -2252,7 +2252,7 @@ static int stats_dump_http(struct stream_interface *si, struct uri_auth *uri)
*/ */
static int stats_dump_proxy(struct stream_interface *si, struct proxy *px, struct uri_auth *uri) static int stats_dump_proxy(struct stream_interface *si, struct proxy *px, struct uri_auth *uri)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
struct channel *rep = si->ib; struct channel *rep = si->ib;
struct server *sv, *svs; /* server and server-state, server-state=server or server->track */ struct server *sv, *svs; /* server and server-state, server-state=server or server->track */
struct listener *l; struct listener *l;
@ -3341,11 +3341,11 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
sess->uniq_id, sess->uniq_id,
sess->listener->proto->name); sess->listener->proto->name);
switch (addr_to_str(&sess->si[0].conn.addr.from, pn, sizeof(pn))) { switch (addr_to_str(&sess->si[0].conn->addr.from, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
chunk_printf(&msg, " source=%s:%d\n", chunk_printf(&msg, " source=%s:%d\n",
pn, get_host_port(&sess->si[0].conn.addr.from)); pn, get_host_port(&sess->si[0].conn->addr.from));
break; break;
case AF_UNIX: case AF_UNIX:
chunk_printf(&msg, " source=unix:%d\n", sess->listener->luid); chunk_printf(&msg, " source=unix:%d\n", sess->listener->luid);
@ -3366,12 +3366,12 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
sess->listener ? sess->listener->name ? sess->listener->name : "?" : "?", sess->listener ? sess->listener->name ? sess->listener->name : "?" : "?",
sess->listener ? sess->listener->luid : 0); sess->listener ? sess->listener->luid : 0);
conn_get_to_addr(&sess->si[0].conn); conn_get_to_addr(sess->si[0].conn);
switch (addr_to_str(&sess->si[0].conn.addr.to, pn, sizeof(pn))) { switch (addr_to_str(&sess->si[0].conn->addr.to, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
chunk_printf(&msg, " addr=%s:%d\n", chunk_printf(&msg, " addr=%s:%d\n",
pn, get_host_port(&sess->si[0].conn.addr.to)); pn, get_host_port(&sess->si[0].conn->addr.to));
break; break;
case AF_UNIX: case AF_UNIX:
chunk_printf(&msg, " addr=unix:%d\n", sess->listener->luid); chunk_printf(&msg, " addr=unix:%d\n", sess->listener->luid);
@ -3390,12 +3390,12 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
else else
chunk_printf(&msg, " backend=<NONE> (id=-1 mode=-)"); chunk_printf(&msg, " backend=<NONE> (id=-1 mode=-)");
conn_get_from_addr(&sess->si[1].conn); conn_get_from_addr(sess->si[1].conn);
switch (addr_to_str(&sess->si[1].conn.addr.from, pn, sizeof(pn))) { switch (addr_to_str(&sess->si[1].conn->addr.from, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
chunk_printf(&msg, " addr=%s:%d\n", chunk_printf(&msg, " addr=%s:%d\n",
pn, get_host_port(&sess->si[1].conn.addr.from)); pn, get_host_port(&sess->si[1].conn->addr.from));
break; break;
case AF_UNIX: case AF_UNIX:
chunk_printf(&msg, " addr=unix\n"); chunk_printf(&msg, " addr=unix\n");
@ -3414,12 +3414,12 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
else else
chunk_printf(&msg, " server=<NONE> (id=-1)"); chunk_printf(&msg, " server=<NONE> (id=-1)");
conn_get_to_addr(&sess->si[1].conn); conn_get_to_addr(sess->si[1].conn);
switch (addr_to_str(&sess->si[1].conn.addr.to, pn, sizeof(pn))) { switch (addr_to_str(&sess->si[1].conn->addr.to, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
chunk_printf(&msg, " addr=%s:%d\n", chunk_printf(&msg, " addr=%s:%d\n",
pn, get_host_port(&sess->si[1].conn.addr.to)); pn, get_host_port(&sess->si[1].conn->addr.to));
break; break;
case AF_UNIX: case AF_UNIX:
chunk_printf(&msg, " addr=unix\n"); chunk_printf(&msg, " addr=unix\n");
@ -3560,7 +3560,7 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
/* If we're forced to shut down, we might have to remove our /* If we're forced to shut down, we might have to remove our
* reference to the last session being dumped. * reference to the last session being dumped.
*/ */
if (si->conn.xprt_st == STAT_ST_LIST) { if (si->conn->xprt_st == STAT_ST_LIST) {
if (!LIST_ISEMPTY(&si->applet.ctx.sess.bref.users)) { if (!LIST_ISEMPTY(&si->applet.ctx.sess.bref.users)) {
LIST_DEL(&si->applet.ctx.sess.bref.users); LIST_DEL(&si->applet.ctx.sess.bref.users);
LIST_INIT(&si->applet.ctx.sess.bref.users); LIST_INIT(&si->applet.ctx.sess.bref.users);
@ -3571,7 +3571,7 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
chunk_init(&msg, trash, global.tune.bufsize); chunk_init(&msg, trash, global.tune.bufsize);
switch (si->conn.xprt_st) { switch (si->conn->xprt_st) {
case STAT_ST_INIT: case STAT_ST_INIT:
/* the function had not been called yet, let's prepare the /* the function had not been called yet, let's prepare the
* buffer for a response. We initialize the current session * buffer for a response. We initialize the current session
@ -3582,7 +3582,7 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
*/ */
LIST_INIT(&si->applet.ctx.sess.bref.users); LIST_INIT(&si->applet.ctx.sess.bref.users);
si->applet.ctx.sess.bref.ref = sessions.n; si->applet.ctx.sess.bref.ref = sessions.n;
si->conn.xprt_st = STAT_ST_LIST; si->conn->xprt_st = STAT_ST_LIST;
/* fall through */ /* fall through */
case STAT_ST_LIST: case STAT_ST_LIST:
@ -3621,13 +3621,13 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
curr_sess->listener->proto->name); curr_sess->listener->proto->name);
switch (addr_to_str(&curr_sess->si[0].conn.addr.from, pn, sizeof(pn))) { switch (addr_to_str(&curr_sess->si[0].conn->addr.from, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
chunk_printf(&msg, chunk_printf(&msg,
" src=%s:%d fe=%s be=%s srv=%s", " src=%s:%d fe=%s be=%s srv=%s",
pn, pn,
get_host_port(&curr_sess->si[0].conn.addr.from), get_host_port(&curr_sess->si[0].conn->addr.from),
curr_sess->fe->id, curr_sess->fe->id,
(curr_sess->be->cap & PR_CAP_BE) ? curr_sess->be->id : "<NONE>", (curr_sess->be->cap & PR_CAP_BE) ? curr_sess->be->id : "<NONE>",
target_srv(&curr_sess->target) ? target_srv(&curr_sess->target)->id : "<none>" target_srv(&curr_sess->target) ? target_srv(&curr_sess->target)->id : "<none>"
@ -3747,11 +3747,11 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
return 1; return 1;
} }
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
/* fall through */ /* fall through */
default: default:
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
return 1; return 1;
} }
} }
@ -3763,14 +3763,14 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
*/ */
static int stats_table_request(struct stream_interface *si, bool show) static int stats_table_request(struct stream_interface *si, bool show)
{ {
struct session *s = si->conn.xprt_ctx; struct session *s = si->conn->xprt_ctx;
struct chunk msg; struct chunk msg;
struct ebmb_node *eb; struct ebmb_node *eb;
int dt; int dt;
bool skip_entry; bool skip_entry;
/* /*
* We have 3 possible states in si->conn.xprt_st : * We have 3 possible states in si->conn->xprt_st :
* - STAT_ST_INIT : the first call * - STAT_ST_INIT : the first call
* - STAT_ST_INFO : the proxy pointer points to the next table to * - STAT_ST_INFO : the proxy pointer points to the next table to
* dump, the entry pointer is NULL ; * dump, the entry pointer is NULL ;
@ -3783,7 +3783,7 @@ static int stats_table_request(struct stream_interface *si, bool show)
if (unlikely(si->ib->flags & (CF_WRITE_ERROR|CF_SHUTW))) { if (unlikely(si->ib->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
/* in case of abort, remove any refcount we might have set on an entry */ /* in case of abort, remove any refcount we might have set on an entry */
if (si->conn.xprt_st == STAT_ST_LIST) { if (si->conn->xprt_st == STAT_ST_LIST) {
si->applet.ctx.table.entry->ref_cnt--; si->applet.ctx.table.entry->ref_cnt--;
stksess_kill_if_expired(&si->applet.ctx.table.proxy->table, si->applet.ctx.table.entry); stksess_kill_if_expired(&si->applet.ctx.table.proxy->table, si->applet.ctx.table.entry);
} }
@ -3792,22 +3792,22 @@ static int stats_table_request(struct stream_interface *si, bool show)
chunk_init(&msg, trash, global.tune.bufsize); chunk_init(&msg, trash, global.tune.bufsize);
while (si->conn.xprt_st != STAT_ST_FIN) { while (si->conn->xprt_st != STAT_ST_FIN) {
switch (si->conn.xprt_st) { switch (si->conn->xprt_st) {
case STAT_ST_INIT: case STAT_ST_INIT:
si->applet.ctx.table.proxy = si->applet.ctx.table.target; si->applet.ctx.table.proxy = si->applet.ctx.table.target;
if (!si->applet.ctx.table.proxy) if (!si->applet.ctx.table.proxy)
si->applet.ctx.table.proxy = proxy; si->applet.ctx.table.proxy = proxy;
si->applet.ctx.table.entry = NULL; si->applet.ctx.table.entry = NULL;
si->conn.xprt_st = STAT_ST_INFO; si->conn->xprt_st = STAT_ST_INFO;
break; break;
case STAT_ST_INFO: case STAT_ST_INFO:
if (!si->applet.ctx.table.proxy || if (!si->applet.ctx.table.proxy ||
(si->applet.ctx.table.target && (si->applet.ctx.table.target &&
si->applet.ctx.table.proxy != si->applet.ctx.table.target)) { si->applet.ctx.table.proxy != si->applet.ctx.table.target)) {
si->conn.xprt_st = STAT_ST_END; si->conn->xprt_st = STAT_ST_END;
break; break;
} }
@ -3823,7 +3823,7 @@ static int stats_table_request(struct stream_interface *si, bool show)
if (eb) { if (eb) {
si->applet.ctx.table.entry = ebmb_entry(eb, struct stksess, key); si->applet.ctx.table.entry = ebmb_entry(eb, struct stksess, key);
si->applet.ctx.table.entry->ref_cnt++; si->applet.ctx.table.entry->ref_cnt++;
si->conn.xprt_st = STAT_ST_LIST; si->conn->xprt_st = STAT_ST_LIST;
break; break;
} }
} }
@ -3903,11 +3903,11 @@ static int stats_table_request(struct stream_interface *si, bool show)
stksess_kill(&si->applet.ctx.table.proxy->table, si->applet.ctx.table.entry); stksess_kill(&si->applet.ctx.table.proxy->table, si->applet.ctx.table.entry);
si->applet.ctx.table.proxy = si->applet.ctx.table.proxy->next; si->applet.ctx.table.proxy = si->applet.ctx.table.proxy->next;
si->conn.xprt_st = STAT_ST_INFO; si->conn->xprt_st = STAT_ST_INFO;
break; break;
case STAT_ST_END: case STAT_ST_END:
si->conn.xprt_st = STAT_ST_FIN; si->conn->xprt_st = STAT_ST_FIN;
break; break;
} }
} }

18
src/frontend.c
View File

@ -139,16 +139,16 @@ int frontend_accept(struct session *s)
else { else {
char pn[INET6_ADDRSTRLEN], sn[INET6_ADDRSTRLEN]; char pn[INET6_ADDRSTRLEN], sn[INET6_ADDRSTRLEN];
conn_get_from_addr(&s->req->prod->conn); conn_get_from_addr(s->req->prod->conn);
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
switch (addr_to_str(&s->req->prod->conn.addr.from, pn, sizeof(pn))) { switch (addr_to_str(&s->req->prod->conn->addr.from, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
addr_to_str(&s->req->prod->conn.addr.to, sn, sizeof(sn)); addr_to_str(&s->req->prod->conn->addr.to, sn, sizeof(sn));
send_log(s->fe, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n", send_log(s->fe, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
pn, get_host_port(&s->req->prod->conn.addr.from), pn, get_host_port(&s->req->prod->conn->addr.from),
sn, get_host_port(&s->req->prod->conn.addr.to), sn, get_host_port(&s->req->prod->conn->addr.to),
s->fe->id, (s->fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP"); s->fe->id, (s->fe->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
break; break;
case AF_UNIX: case AF_UNIX:
@ -165,14 +165,14 @@ int frontend_accept(struct session *s)
char pn[INET6_ADDRSTRLEN]; char pn[INET6_ADDRSTRLEN];
int len = 0; int len = 0;
conn_get_from_addr(&s->req->prod->conn); conn_get_from_addr(s->req->prod->conn);
switch (addr_to_str(&s->req->prod->conn.addr.from, pn, sizeof(pn))) { switch (addr_to_str(&s->req->prod->conn->addr.from, pn, sizeof(pn))) {
case AF_INET: case AF_INET:
case AF_INET6: case AF_INET6:
len = sprintf(trash, "%08x:%s.accept(%04x)=%04x from [%s:%d]\n", len = sprintf(trash, "%08x:%s.accept(%04x)=%04x from [%s:%d]\n",
s->uniq_id, s->fe->id, (unsigned short)s->listener->fd, (unsigned short)cfd, s->uniq_id, s->fe->id, (unsigned short)s->listener->fd, (unsigned short)cfd,
pn, get_host_port(&s->req->prod->conn.addr.from)); pn, get_host_port(&s->req->prod->conn->addr.from));
break; break;
case AF_UNIX: case AF_UNIX:
/* UNIX socket, only the destination is known */ /* UNIX socket, only the destination is known */

3
src/haproxy.c
View File

@ -77,6 +77,7 @@
#include <proto/backend.h> #include <proto/backend.h>
#include <proto/channel.h> #include <proto/channel.h>
#include <proto/checks.h> #include <proto/checks.h>
#include <proto/connection.h>
#include <proto/fd.h> #include <proto/fd.h>
#include <proto/hdr_idx.h> #include <proto/hdr_idx.h>
#include <proto/listener.h> #include <proto/listener.h>
@ -430,6 +431,7 @@ void init(int argc, char **argv)
signal_init(); signal_init();
init_task(); init_task();
init_session(); init_session();
init_connection();
/* warning, we init buffers later */ /* warning, we init buffers later */
init_pendconn(); init_pendconn();
init_proto_http(); init_proto_http();
@ -1122,6 +1124,7 @@ void deinit(void)
} }
pool_destroy2(pool2_session); pool_destroy2(pool2_session);
pool_destroy2(pool2_connection);
pool_destroy2(pool2_buffer); pool_destroy2(pool2_buffer);
pool_destroy2(pool2_channel); pool_destroy2(pool2_channel);
pool_destroy2(pool2_requri); pool_destroy2(pool2_requri);

28
src/log.c
View File

@ -842,7 +842,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_CLIENTIP: // %Ci case LOG_FMT_CLIENTIP: // %Ci
ret = lf_ip(tmplog, (struct sockaddr *)&s->req->prod->conn.addr.from, ret = lf_ip(tmplog, (struct sockaddr *)&s->req->prod->conn->addr.from,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -851,10 +851,10 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_CLIENTPORT: // %Cp case LOG_FMT_CLIENTPORT: // %Cp
if (s->req->prod->conn.addr.from.ss_family == AF_UNIX) { if (s->req->prod->conn->addr.from.ss_family == AF_UNIX) {
ret = ltoa_o(s->listener->luid, tmplog, dst + maxsize - tmplog); ret = ltoa_o(s->listener->luid, tmplog, dst + maxsize - tmplog);
} else { } else {
ret = lf_port(tmplog, (struct sockaddr *)&s->req->prod->conn.addr.from, ret = lf_port(tmplog, (struct sockaddr *)&s->req->prod->conn->addr.from,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
} }
if (ret == NULL) if (ret == NULL)
@ -864,8 +864,8 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_FRONTENDIP: // %Fi case LOG_FMT_FRONTENDIP: // %Fi
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
ret = lf_ip(tmplog, (struct sockaddr *)&s->req->prod->conn.addr.to, ret = lf_ip(tmplog, (struct sockaddr *)&s->req->prod->conn->addr.to,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -874,12 +874,12 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_FRONTENDPORT: // %Fp case LOG_FMT_FRONTENDPORT: // %Fp
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
if (s->req->prod->conn.addr.to.ss_family == AF_UNIX) { if (s->req->prod->conn->addr.to.ss_family == AF_UNIX) {
ret = ltoa_o(s->listener->luid, ret = ltoa_o(s->listener->luid,
tmplog, dst + maxsize - tmplog); tmplog, dst + maxsize - tmplog);
} else { } else {
ret = lf_port(tmplog, (struct sockaddr *)&s->req->prod->conn.addr.to, ret = lf_port(tmplog, (struct sockaddr *)&s->req->prod->conn->addr.to,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
} }
if (ret == NULL) if (ret == NULL)
@ -889,7 +889,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_BACKENDIP: // %Bi case LOG_FMT_BACKENDIP: // %Bi
ret = lf_ip(tmplog, (struct sockaddr *)&s->req->cons->conn.addr.from, ret = lf_ip(tmplog, (struct sockaddr *)&s->req->cons->conn->addr.from,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -898,7 +898,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_BACKENDPORT: // %Bp case LOG_FMT_BACKENDPORT: // %Bp
ret = lf_port(tmplog, (struct sockaddr *)&s->req->cons->conn.addr.from, ret = lf_port(tmplog, (struct sockaddr *)&s->req->cons->conn->addr.from,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -907,7 +907,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_SERVERIP: // %Si case LOG_FMT_SERVERIP: // %Si
ret = lf_ip(tmplog, (struct sockaddr *)&s->req->cons->conn.addr.to, ret = lf_ip(tmplog, (struct sockaddr *)&s->req->cons->conn->addr.to,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -916,7 +916,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
break; break;
case LOG_FMT_SERVERPORT: // %Sp case LOG_FMT_SERVERPORT: // %Sp
ret = lf_port(tmplog, (struct sockaddr *)&s->req->cons->conn.addr.to, ret = lf_port(tmplog, (struct sockaddr *)&s->req->cons->conn->addr.to,
dst + maxsize - tmplog, tmp); dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -1007,7 +1007,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
case LOG_FMT_SSL_CIPHER: // %sslc case LOG_FMT_SSL_CIPHER: // %sslc
src = NULL; src = NULL;
if (s->listener->xprt == &ssl_sock) if (s->listener->xprt == &ssl_sock)
src = ssl_sock_get_cipher_name(&s->si[0].conn); src = ssl_sock_get_cipher_name(s->si[0].conn);
ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp); ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;
@ -1018,7 +1018,7 @@ int build_logline(struct session *s, char *dst, size_t maxsize, struct list *lis
case LOG_FMT_SSL_VERSION: // %sslv case LOG_FMT_SSL_VERSION: // %sslv
src = NULL; src = NULL;
if (s->listener->xprt == &ssl_sock) if (s->listener->xprt == &ssl_sock)
src = ssl_sock_get_proto_version(&s->si[0].conn); src = ssl_sock_get_proto_version(s->si[0].conn);
ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp); ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
if (ret == NULL) if (ret == NULL)
goto out; goto out;

64
src/peers.c
View File

@ -184,9 +184,9 @@ static void peer_session_release(struct stream_interface *si)
{ {
struct task *t = (struct task *)si->owner; struct task *t = (struct task *)si->owner;
struct session *s = (struct session *)t->context; struct session *s = (struct session *)t->context;
struct peer_session *ps = (struct peer_session *)si->conn.xprt_ctx; struct peer_session *ps = (struct peer_session *)si->conn->xprt_ctx;
/* si->conn.xprt_ctx is not a peer session */ /* si->conn->xprt_ctx is not a peer session */
if (si->applet.st0 < PEER_SESSION_SENDSUCCESS) if (si->applet.st0 < PEER_SESSION_SENDSUCCESS)
return; return;
@ -226,7 +226,7 @@ static void peer_io_handler(struct stream_interface *si)
switchstate: switchstate:
switch(si->applet.st0) { switch(si->applet.st0) {
case PEER_SESSION_ACCEPT: case PEER_SESSION_ACCEPT:
si->conn.xprt_ctx = NULL; si->conn->xprt_ctx = NULL;
si->applet.st0 = PEER_SESSION_GETVERSION; si->applet.st0 = PEER_SESSION_GETVERSION;
/* fall through */ /* fall through */
case PEER_SESSION_GETVERSION: case PEER_SESSION_GETVERSION:
@ -332,12 +332,12 @@ switchstate:
goto switchstate; goto switchstate;
} }
si->conn.xprt_ctx = curpeer; si->conn->xprt_ctx = curpeer;
si->applet.st0 = PEER_SESSION_GETTABLE; si->applet.st0 = PEER_SESSION_GETTABLE;
/* fall through */ /* fall through */
} }
case PEER_SESSION_GETTABLE: { case PEER_SESSION_GETTABLE: {
struct peer *curpeer = (struct peer *)si->conn.xprt_ctx; struct peer *curpeer = (struct peer *)si->conn->xprt_ctx;
struct shared_table *st; struct shared_table *st;
struct peer_session *ps = NULL; struct peer_session *ps = NULL;
unsigned long key_type; unsigned long key_type;
@ -348,12 +348,12 @@ switchstate:
if (reql <= 0) { /* closed or EOL not found */ if (reql <= 0) { /* closed or EOL not found */
if (reql == 0) if (reql == 0)
goto out; goto out;
si->conn.xprt_ctx = NULL; si->conn->xprt_ctx = NULL;
si->applet.st0 = PEER_SESSION_END; si->applet.st0 = PEER_SESSION_END;
goto switchstate; goto switchstate;
} }
/* Re init si->conn.xprt_ctx to null, to handle correctly a release case */ /* Re init si->conn->xprt_ctx to null, to handle correctly a release case */
si->conn.xprt_ctx = NULL; si->conn->xprt_ctx = NULL;
if (trash[reql-1] != '\n') { if (trash[reql-1] != '\n') {
/* Incomplete line, we quit */ /* Incomplete line, we quit */
@ -379,7 +379,7 @@ switchstate:
p = strchr(p+1, ' '); p = strchr(p+1, ' ');
if (!p) { if (!p) {
si->conn.xprt_ctx = NULL; si->conn->xprt_ctx = NULL;
si->applet.st0 = PEER_SESSION_EXIT; si->applet.st0 = PEER_SESSION_EXIT;
si->applet.st1 = PEER_SESSION_ERRPROTO; si->applet.st1 = PEER_SESSION_ERRPROTO;
goto switchstate; goto switchstate;
@ -438,12 +438,12 @@ switchstate:
goto switchstate; goto switchstate;
} }
si->conn.xprt_ctx = ps; si->conn->xprt_ctx = ps;
si->applet.st0 = PEER_SESSION_SENDSUCCESS; si->applet.st0 = PEER_SESSION_SENDSUCCESS;
/* fall through */ /* fall through */
} }
case PEER_SESSION_SENDSUCCESS:{ case PEER_SESSION_SENDSUCCESS:{
struct peer_session *ps = (struct peer_session *)si->conn.xprt_ctx; struct peer_session *ps = (struct peer_session *)si->conn->xprt_ctx;
repl = snprintf(trash, global.tune.bufsize, "%d\n", PEER_SESSION_SUCCESSCODE); repl = snprintf(trash, global.tune.bufsize, "%d\n", PEER_SESSION_SUCCESSCODE);
repl = bi_putblk(si->ib, trash, repl); repl = bi_putblk(si->ib, trash, repl);
@ -493,7 +493,7 @@ switchstate:
goto switchstate; goto switchstate;
} }
case PEER_SESSION_CONNECT: { case PEER_SESSION_CONNECT: {
struct peer_session *ps = (struct peer_session *)si->conn.xprt_ctx; struct peer_session *ps = (struct peer_session *)si->conn->xprt_ctx;
/* Send headers */ /* Send headers */
repl = snprintf(trash, global.tune.bufsize, repl = snprintf(trash, global.tune.bufsize,
@ -523,7 +523,7 @@ switchstate:
/* fall through */ /* fall through */
} }
case PEER_SESSION_GETSTATUS: { case PEER_SESSION_GETSTATUS: {
struct peer_session *ps = (struct peer_session *)si->conn.xprt_ctx; struct peer_session *ps = (struct peer_session *)si->conn->xprt_ctx;
if (si->ib->flags & CF_WRITE_PARTIAL) if (si->ib->flags & CF_WRITE_PARTIAL)
ps->statuscode = PEER_SESSION_CONNECTEDCODE; ps->statuscode = PEER_SESSION_CONNECTEDCODE;
@ -594,7 +594,7 @@ switchstate:
/* fall through */ /* fall through */
} }
case PEER_SESSION_WAITMSG: { case PEER_SESSION_WAITMSG: {
struct peer_session *ps = (struct peer_session *)si->conn.xprt_ctx; struct peer_session *ps = (struct peer_session *)si->conn->xprt_ctx;
char c; char c;
int totl = 0; int totl = 0;
@ -1052,8 +1052,8 @@ static void peer_session_forceshutdown(struct session * session)
{ {
struct stream_interface *oldsi; struct stream_interface *oldsi;
if (session->si[0].conn.target.type == TARG_TYPE_APPLET && if (session->si[0].conn->target.type == TARG_TYPE_APPLET &&
session->si[0].conn.target.ptr.a == &peer_applet) { session->si[0].conn->target.ptr.a == &peer_applet) {
oldsi = &session->si[0]; oldsi = &session->si[0];
} }
else { else {
@ -1063,7 +1063,7 @@ static void peer_session_forceshutdown(struct session * session)
/* call release to reinit resync states if needed */ /* call release to reinit resync states if needed */
peer_session_release(oldsi); peer_session_release(oldsi);
oldsi->applet.st0 = PEER_SESSION_END; oldsi->applet.st0 = PEER_SESSION_END;
oldsi->conn.xprt_ctx = NULL; oldsi->conn->xprt_ctx = NULL;
task_wakeup(session->task, TASK_WOKEN_MSG); task_wakeup(session->task, TASK_WOKEN_MSG);
} }
@ -1077,8 +1077,8 @@ int peer_accept(struct session *s)
{ {
/* we have a dedicated I/O handler for the stats */ /* we have a dedicated I/O handler for the stats */
stream_int_register_handler(&s->si[1], &peer_applet); stream_int_register_handler(&s->si[1], &peer_applet);
copy_target(&s->target, &s->si[1].conn.target); // for logging only copy_target(&s->target, &s->si[1].conn->target); // for logging only
s->si[1].conn.xprt_ctx = s; s->si[1].conn->xprt_ctx = s;
s->si[1].applet.st0 = PEER_SESSION_ACCEPT; s->si[1].applet.st0 = PEER_SESSION_ACCEPT;
tv_zero(&s->logs.tv_request); tv_zero(&s->logs.tv_request);
@ -1115,6 +1115,12 @@ static struct session *peer_session_create(struct peer *peer, struct peer_sessio
goto out_close; goto out_close;
} }
if (unlikely((s->si[0].conn = pool_alloc2(pool2_connection)) == NULL))
goto out_fail_conn0;
if (unlikely((s->si[1].conn = pool_alloc2(pool2_connection)) == NULL))
goto out_fail_conn1;
LIST_ADDQ(&sessions, &s->list); LIST_ADDQ(&sessions, &s->list);
LIST_INIT(&s->back_refs); LIST_INIT(&s->back_refs);
@ -1135,7 +1141,7 @@ static struct session *peer_session_create(struct peer *peer, struct peer_sessio
t->context = s; t->context = s;
t->nice = l->nice; t->nice = l->nice;
memcpy(&s->si[1].conn.addr.to, &peer->addr, sizeof(s->si[1].conn.addr.to)); memcpy(&s->si[1].conn->addr.to, &peer->addr, sizeof(s->si[1].conn->addr.to));
s->task = t; s->task = t;
s->listener = l; s->listener = l;
@ -1147,15 +1153,15 @@ static struct session *peer_session_create(struct peer *peer, struct peer_sessio
s->req = s->rep = NULL; /* will be allocated later */ s->req = s->rep = NULL; /* will be allocated later */
s->si[0].conn.t.sock.fd = -1; s->si[0].conn->t.sock.fd = -1;
s->si[0].conn.flags = CO_FL_NONE; s->si[0].conn->flags = CO_FL_NONE;
s->si[0].owner = t; s->si[0].owner = t;
s->si[0].state = s->si[0].prev_state = SI_ST_EST; s->si[0].state = s->si[0].prev_state = SI_ST_EST;
s->si[0].err_type = SI_ET_NONE; s->si[0].err_type = SI_ET_NONE;
s->si[0].err_loc = NULL; s->si[0].err_loc = NULL;
s->si[0].release = NULL; s->si[0].release = NULL;
s->si[0].send_proxy_ofs = 0; s->si[0].send_proxy_ofs = 0;
set_target_client(&s->si[0].conn.target, l); set_target_client(&s->si[0].conn->target, l);
s->si[0].exp = TICK_ETERNITY; s->si[0].exp = TICK_ETERNITY;
s->si[0].flags = SI_FL_NONE; s->si[0].flags = SI_FL_NONE;
if (s->fe->options2 & PR_O2_INDEPSTR) if (s->fe->options2 & PR_O2_INDEPSTR)
@ -1163,10 +1169,10 @@ static struct session *peer_session_create(struct peer *peer, struct peer_sessio
stream_int_register_handler(&s->si[0], &peer_applet); stream_int_register_handler(&s->si[0], &peer_applet);
s->si[0].applet.st0 = PEER_SESSION_CONNECT; s->si[0].applet.st0 = PEER_SESSION_CONNECT;
s->si[0].conn.xprt_ctx = (void *)ps; s->si[0].conn->xprt_ctx = (void *)ps;
s->si[1].conn.t.sock.fd = -1; /* just to help with debugging */ s->si[1].conn->t.sock.fd = -1; /* just to help with debugging */
s->si[1].conn.flags = CO_FL_NONE; s->si[1].conn->flags = CO_FL_NONE;
s->si[1].owner = t; s->si[1].owner = t;
s->si[1].state = s->si[1].prev_state = SI_ST_ASS; s->si[1].state = s->si[1].prev_state = SI_ST_ASS;
s->si[1].conn_retries = p->conn_retries; s->si[1].conn_retries = p->conn_retries;
@ -1174,7 +1180,7 @@ static struct session *peer_session_create(struct peer *peer, struct peer_sessio
s->si[1].err_loc = NULL; s->si[1].err_loc = NULL;
s->si[1].release = NULL; s->si[1].release = NULL;
s->si[1].send_proxy_ofs = 0; s->si[1].send_proxy_ofs = 0;
set_target_proxy(&s->si[1].conn.target, s->be); set_target_proxy(&s->si[1].conn->target, s->be);
si_prepare_conn(&s->si[1], peer->proto, peer->xprt); si_prepare_conn(&s->si[1], peer->proto, peer->xprt);
s->si[1].exp = TICK_ETERNITY; s->si[1].exp = TICK_ETERNITY;
s->si[1].flags = SI_FL_NONE; s->si[1].flags = SI_FL_NONE;
@ -1293,6 +1299,10 @@ static struct session *peer_session_create(struct peer *peer, struct peer_sessio
task_free(t); task_free(t);
out_free_session: out_free_session:
LIST_DEL(&s->list); LIST_DEL(&s->list);
pool_free2(pool2_connection, s->si[1].conn);
out_fail_conn1:
pool_free2(pool2_connection, s->si[0].conn);
out_fail_conn0:
pool_free2(pool2_session, s); pool_free2(pool2_session, s);
out_close: out_close:
return s; return s;

46
src/proto_http.c
View File

@ -3184,8 +3184,8 @@ int http_process_req_common(struct session *s, struct channel *req, int an_bit,
s->logs.tv_request = now; s->logs.tv_request = now;
s->task->nice = -32; /* small boost for HTTP statistics */ s->task->nice = -32; /* small boost for HTTP statistics */
stream_int_register_handler(s->rep->prod, &http_stats_applet); stream_int_register_handler(s->rep->prod, &http_stats_applet);
copy_target(&s->target, &s->rep->prod->conn.target); // for logging only copy_target(&s->target, &s->rep->prod->conn->target); // for logging only
s->rep->prod->conn.xprt_ctx = s; s->rep->prod->conn->xprt_ctx = s;
s->rep->prod->applet.st0 = s->rep->prod->applet.st1 = 0; s->rep->prod->applet.st0 = s->rep->prod->applet.st1 = 0;
req->analysers = 0; req->analysers = 0;
if (s->fe == s->be) /* report it if the request was intercepted by the frontend */ if (s->fe == s->be) /* report it if the request was intercepted by the frontend */
@ -3493,7 +3493,7 @@ int http_process_request(struct session *s, struct channel *req, int an_bit)
* parsing incoming request. * parsing incoming request.
*/ */
if ((s->be->options & PR_O_HTTP_PROXY) && !(s->flags & SN_ADDR_SET)) { if ((s->be->options & PR_O_HTTP_PROXY) && !(s->flags & SN_ADDR_SET)) {
url2sa(req->buf->p + msg->sl.rq.u, msg->sl.rq.u_l, &s->req->cons->conn.addr.to); url2sa(req->buf->p + msg->sl.rq.u, msg->sl.rq.u_l, &s->req->cons->conn->addr.to);
} }
/* /*
@ -3543,19 +3543,19 @@ int http_process_request(struct session *s, struct channel *req, int an_bit)
* and we found it, so don't do anything. * and we found it, so don't do anything.
*/ */
} }
else if (s->req->prod->conn.addr.from.ss_family == AF_INET) { else if (s->req->prod->conn->addr.from.ss_family == AF_INET) {
/* Add an X-Forwarded-For header unless the source IP is /* Add an X-Forwarded-For header unless the source IP is
* in the 'except' network range. * in the 'except' network range.
*/ */
if ((!s->fe->except_mask.s_addr || if ((!s->fe->except_mask.s_addr ||
(((struct sockaddr_in *)&s->req->prod->conn.addr.from)->sin_addr.s_addr & s->fe->except_mask.s_addr) (((struct sockaddr_in *)&s->req->prod->conn->addr.from)->sin_addr.s_addr & s->fe->except_mask.s_addr)
!= s->fe->except_net.s_addr) && != s->fe->except_net.s_addr) &&
(!s->be->except_mask.s_addr || (!s->be->except_mask.s_addr ||
(((struct sockaddr_in *)&s->req->prod->conn.addr.from)->sin_addr.s_addr & s->be->except_mask.s_addr) (((struct sockaddr_in *)&s->req->prod->conn->addr.from)->sin_addr.s_addr & s->be->except_mask.s_addr)
!= s->be->except_net.s_addr)) { != s->be->except_net.s_addr)) {
int len; int len;
unsigned char *pn; unsigned char *pn;
pn = (unsigned char *)&((struct sockaddr_in *)&s->req->prod->conn.addr.from)->sin_addr; pn = (unsigned char *)&((struct sockaddr_in *)&s->req->prod->conn->addr.from)->sin_addr;
/* Note: we rely on the backend to get the header name to be used for /* Note: we rely on the backend to get the header name to be used for
* x-forwarded-for, because the header is really meant for the backends. * x-forwarded-for, because the header is really meant for the backends.
@ -3575,14 +3575,14 @@ int http_process_request(struct session *s, struct channel *req, int an_bit)
goto return_bad_req; goto return_bad_req;
} }
} }
else if (s->req->prod->conn.addr.from.ss_family == AF_INET6) { else if (s->req->prod->conn->addr.from.ss_family == AF_INET6) {
/* FIXME: for the sake of completeness, we should also support /* FIXME: for the sake of completeness, we should also support
* 'except' here, although it is mostly useless in this case. * 'except' here, although it is mostly useless in this case.
*/ */
int len; int len;
char pn[INET6_ADDRSTRLEN]; char pn[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, inet_ntop(AF_INET6,
(const void *)&((struct sockaddr_in6 *)(&s->req->prod->conn.addr.from))->sin6_addr, (const void *)&((struct sockaddr_in6 *)(&s->req->prod->conn->addr.from))->sin6_addr,
pn, sizeof(pn)); pn, sizeof(pn));
/* Note: we rely on the backend to get the header name to be used for /* Note: we rely on the backend to get the header name to be used for
@ -3611,22 +3611,22 @@ int http_process_request(struct session *s, struct channel *req, int an_bit)
if ((s->fe->options | s->be->options) & PR_O_ORGTO) { if ((s->fe->options | s->be->options) & PR_O_ORGTO) {
/* FIXME: don't know if IPv6 can handle that case too. */ /* FIXME: don't know if IPv6 can handle that case too. */
if (s->req->prod->conn.addr.from.ss_family == AF_INET) { if (s->req->prod->conn->addr.from.ss_family == AF_INET) {
/* Add an X-Original-To header unless the destination IP is /* Add an X-Original-To header unless the destination IP is
* in the 'except' network range. * in the 'except' network range.
*/ */
conn_get_to_addr(&s->req->prod->conn); conn_get_to_addr(s->req->prod->conn);
if (s->req->prod->conn.addr.to.ss_family == AF_INET && if (s->req->prod->conn->addr.to.ss_family == AF_INET &&
((!s->fe->except_mask_to.s_addr || ((!s->fe->except_mask_to.s_addr ||
(((struct sockaddr_in *)&s->req->prod->conn.addr.to)->sin_addr.s_addr & s->fe->except_mask_to.s_addr) (((struct sockaddr_in *)&s->req->prod->conn->addr.to)->sin_addr.s_addr & s->fe->except_mask_to.s_addr)
!= s->fe->except_to.s_addr) && != s->fe->except_to.s_addr) &&
(!s->be->except_mask_to.s_addr || (!s->be->except_mask_to.s_addr ||
(((struct sockaddr_in *)&s->req->prod->conn.addr.to)->sin_addr.s_addr & s->be->except_mask_to.s_addr) (((struct sockaddr_in *)&s->req->prod->conn->addr.to)->sin_addr.s_addr & s->be->except_mask_to.s_addr)
!= s->be->except_to.s_addr))) { != s->be->except_to.s_addr))) {
int len; int len;
unsigned char *pn; unsigned char *pn;
pn = (unsigned char *)&((struct sockaddr_in *)&s->req->prod->conn.addr.to)->sin_addr; pn = (unsigned char *)&((struct sockaddr_in *)&s->req->prod->conn->addr.to)->sin_addr;
/* Note: we rely on the backend to get the header name to be used for /* Note: we rely on the backend to get the header name to be used for
* x-original-to, because the header is really meant for the backends. * x-original-to, because the header is really meant for the backends.
@ -4046,8 +4046,8 @@ void http_end_txn_clean_session(struct session *s)
clear_target(&s->target); clear_target(&s->target);
s->req->cons->state = s->req->cons->prev_state = SI_ST_INI; s->req->cons->state = s->req->cons->prev_state = SI_ST_INI;
s->req->cons->conn.t.sock.fd = -1; /* just to help with debugging */ s->req->cons->conn->t.sock.fd = -1; /* just to help with debugging */
s->req->cons->conn.flags = CO_FL_NONE; s->req->cons->conn->flags = CO_FL_NONE;
s->req->cons->err_type = SI_ET_NONE; s->req->cons->err_type = SI_ET_NONE;
s->req->cons->conn_retries = 0; /* used for logging too */ s->req->cons->conn_retries = 0; /* used for logging too */
s->req->cons->err_loc = NULL; s->req->cons->err_loc = NULL;
@ -7562,7 +7562,7 @@ void http_capture_bad_message(struct error_snapshot *es, struct session *s,
es->sid = s->uniq_id; es->sid = s->uniq_id;
es->srv = target_srv(&s->target); es->srv = target_srv(&s->target);
es->oe = other_end; es->oe = other_end;
es->src = s->req->prod->conn.addr.from; es->src = s->req->prod->conn->addr.from;
es->state = state; es->state = state;
es->ev_id = error_snapshot_id++; es->ev_id = error_snapshot_id++;
es->b_flags = chn->flags; es->b_flags = chn->flags;
@ -8145,11 +8145,11 @@ smp_fetch_url_ip(struct proxy *px, struct session *l4, void *l7, unsigned int op
CHECK_HTTP_MESSAGE_FIRST(); CHECK_HTTP_MESSAGE_FIRST();
/* Parse HTTP request */ /* Parse HTTP request */
url2sa(txn->req.chn->buf->p + txn->req.sl.rq.u, txn->req.sl.rq.u_l, &l4->req->cons->conn.addr.to); url2sa(txn->req.chn->buf->p + txn->req.sl.rq.u, txn->req.sl.rq.u_l, &l4->req->cons->conn->addr.to);
if (((struct sockaddr_in *)&l4->req->cons->conn.addr.to)->sin_family != AF_INET) if (((struct sockaddr_in *)&l4->req->cons->conn->addr.to)->sin_family != AF_INET)
return 0; return 0;
smp->type = SMP_T_IPV4; smp->type = SMP_T_IPV4;
smp->data.ipv4 = ((struct sockaddr_in *)&l4->req->cons->conn.addr.to)->sin_addr; smp->data.ipv4 = ((struct sockaddr_in *)&l4->req->cons->conn->addr.to)->sin_addr;
/* /*
* If we are parsing url in frontend space, we prepare backend stage * If we are parsing url in frontend space, we prepare backend stage
@ -8171,9 +8171,9 @@ smp_fetch_url_port(struct proxy *px, struct session *l4, void *l7, unsigned int
CHECK_HTTP_MESSAGE_FIRST(); CHECK_HTTP_MESSAGE_FIRST();
/* Same optimization as url_ip */ /* Same optimization as url_ip */
url2sa(txn->req.chn->buf->p + txn->req.sl.rq.u, txn->req.sl.rq.u_l, &l4->req->cons->conn.addr.to); url2sa(txn->req.chn->buf->p + txn->req.sl.rq.u, txn->req.sl.rq.u_l, &l4->req->cons->conn->addr.to);
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
smp->data.uint = ntohs(((struct sockaddr_in *)&l4->req->cons->conn.addr.to)->sin_port); smp->data.uint = ntohs(((struct sockaddr_in *)&l4->req->cons->conn->addr.to)->sin_port);
if (px->options & PR_O_HTTP_PROXY) if (px->options & PR_O_HTTP_PROXY)
l4->flags |= SN_ADDR_SET; l4->flags |= SN_ADDR_SET;

28
src/proto_tcp.c
View File

@ -863,7 +863,7 @@ int tcp_inspect_request(struct session *s, struct channel *req, int an_bit)
* to consider rule->act_prm->trk_ctr.type. * to consider rule->act_prm->trk_ctr.type.
*/ */
t = rule->act_prm.trk_ctr.table.t; t = rule->act_prm.trk_ctr.table.t;
ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn.addr.from)); ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn->addr.from));
if (ts) { if (ts) {
session_track_stkctr1(s, t, ts); session_track_stkctr1(s, t, ts);
if (s->fe != s->be) if (s->fe != s->be)
@ -879,7 +879,7 @@ int tcp_inspect_request(struct session *s, struct channel *req, int an_bit)
* to consider rule->act_prm->trk_ctr.type. * to consider rule->act_prm->trk_ctr.type.
*/ */
t = rule->act_prm.trk_ctr.table.t; t = rule->act_prm.trk_ctr.table.t;
ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn.addr.from)); ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn->addr.from));
if (ts) { if (ts) {
session_track_stkctr2(s, t, ts); session_track_stkctr2(s, t, ts);
if (s->fe != s->be) if (s->fe != s->be)
@ -1033,7 +1033,7 @@ int tcp_exec_req_rules(struct session *s)
* to consider rule->act_prm->trk_ctr.type. * to consider rule->act_prm->trk_ctr.type.
*/ */
t = rule->act_prm.trk_ctr.table.t; t = rule->act_prm.trk_ctr.table.t;
ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn.addr.from)); ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn->addr.from));
if (ts) if (ts)
session_track_stkctr1(s, t, ts); session_track_stkctr1(s, t, ts);
} }
@ -1046,7 +1046,7 @@ int tcp_exec_req_rules(struct session *s)
* to consider rule->act_prm->trk_ctr.type. * to consider rule->act_prm->trk_ctr.type.
*/ */
t = rule->act_prm.trk_ctr.table.t; t = rule->act_prm.trk_ctr.table.t;
ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn.addr.from)); ts = stktable_get_entry(t, addr_to_stktable_key(&s->si[0].conn->addr.from));
if (ts) if (ts)
session_track_stkctr2(s, t, ts); session_track_stkctr2(s, t, ts);
} }
@ -1511,13 +1511,13 @@ static int
smp_fetch_src(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_src(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
switch (l4->si[0].conn.addr.from.ss_family) { switch (l4->si[0].conn->addr.from.ss_family) {
case AF_INET: case AF_INET:
smp->data.ipv4 = ((struct sockaddr_in *)&l4->si[0].conn.addr.from)->sin_addr; smp->data.ipv4 = ((struct sockaddr_in *)&l4->si[0].conn->addr.from)->sin_addr;
smp->type = SMP_T_IPV4; smp->type = SMP_T_IPV4;
break; break;
case AF_INET6: case AF_INET6:
smp->data.ipv6 = ((struct sockaddr_in6 *)(&l4->si[0].conn.addr.from))->sin6_addr; smp->data.ipv6 = ((struct sockaddr_in6 *)(&l4->si[0].conn->addr.from))->sin6_addr;
smp->type = SMP_T_IPV6; smp->type = SMP_T_IPV6;
break; break;
default: default:
@ -1534,7 +1534,7 @@ smp_fetch_sport(struct proxy *px, struct session *l4, void *l7, unsigned int opt
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
if (!(smp->data.uint = get_host_port(&l4->si[0].conn.addr.from))) if (!(smp->data.uint = get_host_port(&l4->si[0].conn->addr.from)))
return 0; return 0;
smp->flags = 0; smp->flags = 0;
@ -1546,15 +1546,15 @@ static int
smp_fetch_dst(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_dst(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
conn_get_to_addr(&l4->si[0].conn); conn_get_to_addr(l4->si[0].conn);
switch (l4->si[0].conn.addr.to.ss_family) { switch (l4->si[0].conn->addr.to.ss_family) {
case AF_INET: case AF_INET:
smp->data.ipv4 = ((struct sockaddr_in *)&l4->si[0].conn.addr.to)->sin_addr; smp->data.ipv4 = ((struct sockaddr_in *)&l4->si[0].conn->addr.to)->sin_addr;
smp->type = SMP_T_IPV4; smp->type = SMP_T_IPV4;
break; break;
case AF_INET6: case AF_INET6:
smp->data.ipv6 = ((struct sockaddr_in6 *)(&l4->si[0].conn.addr.to))->sin6_addr; smp->data.ipv6 = ((struct sockaddr_in6 *)(&l4->si[0].conn->addr.to))->sin6_addr;
smp->type = SMP_T_IPV6; smp->type = SMP_T_IPV6;
break; break;
default: default:
@ -1570,10 +1570,10 @@ static int
smp_fetch_dport(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_dport(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
conn_get_to_addr(&l4->si[0].conn); conn_get_to_addr(l4->si[0].conn);
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
if (!(smp->data.uint = get_host_port(&l4->si[0].conn.addr.to))) if (!(smp->data.uint = get_host_port(&l4->si[0].conn->addr.to)))
return 0; return 0;
smp->flags = 0; smp->flags = 0;

126
src/session.c
View File

@ -83,6 +83,12 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
if (unlikely((s = pool_alloc2(pool2_session)) == NULL)) if (unlikely((s = pool_alloc2(pool2_session)) == NULL))
goto out_close; goto out_close;
if (unlikely((s->si[0].conn = pool_alloc2(pool2_connection)) == NULL))
goto out_fail_conn0;
if (unlikely((s->si[1].conn = pool_alloc2(pool2_connection)) == NULL))
goto out_fail_conn1;
/* minimum session initialization required for an embryonic session is /* minimum session initialization required for an embryonic session is
* fairly low. We need very little to execute L4 ACLs, then we need a * fairly low. We need very little to execute L4 ACLs, then we need a
* task to make the client-side connection live on its own. * task to make the client-side connection live on its own.
@ -100,11 +106,11 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
s->fe = p; s->fe = p;
/* OK, we're keeping the session, so let's properly initialize the session */ /* OK, we're keeping the session, so let's properly initialize the session */
s->si[0].conn.t.sock.fd = cfd; s->si[0].conn->t.sock.fd = cfd;
s->si[0].conn.ctrl = l->proto; s->si[0].conn->ctrl = l->proto;
s->si[0].conn.flags = CO_FL_NONE; s->si[0].conn->flags = CO_FL_NONE;
s->si[0].conn.addr.from = *addr; s->si[0].conn->addr.from = *addr;
set_target_client(&s->si[0].conn.target, l); set_target_client(&s->si[0].conn->target, l);
s->logs.accept_date = date; /* user-visible date for logging */ s->logs.accept_date = date; /* user-visible date for logging */
s->logs.tv_accept = now; /* corrected date for internal use */ s->logs.tv_accept = now; /* corrected date for internal use */
@ -165,8 +171,8 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
/* wait for a PROXY protocol header */ /* wait for a PROXY protocol header */
if (l->options & LI_O_ACC_PROXY) { if (l->options & LI_O_ACC_PROXY) {
s->si[0].conn.flags |= CO_FL_ACCEPT_PROXY; s->si[0].conn->flags |= CO_FL_ACCEPT_PROXY;
conn_sock_want_recv(&s->si[0].conn); conn_sock_want_recv(s->si[0].conn);
} }
if (unlikely((t = task_new()) == NULL)) if (unlikely((t = task_new()) == NULL))
@ -180,14 +186,14 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
* but not initialized. Also note we need to be careful as the stream * but not initialized. Also note we need to be careful as the stream
* int is not initialized yet. * int is not initialized yet.
*/ */
conn_prepare(&s->si[0].conn, &sess_conn_cb, l->proto, l->xprt, s); conn_prepare(s->si[0].conn, &sess_conn_cb, l->proto, l->xprt, s);
/* finish initialization of the accepted file descriptor */ /* finish initialization of the accepted file descriptor */
fd_insert(cfd); fd_insert(cfd);
fdtab[cfd].owner = &s->si[0].conn; fdtab[cfd].owner = s->si[0].conn;
fdtab[cfd].iocb = conn_fd_handler; fdtab[cfd].iocb = conn_fd_handler;
conn_data_want_recv(&s->si[0].conn); conn_data_want_recv(s->si[0].conn);
if (conn_xprt_init(&s->si[0].conn) < 0) if (conn_xprt_init(s->si[0].conn) < 0)
goto out_free_task; goto out_free_task;
/* OK, now either we have a pending handshake to execute with and /* OK, now either we have a pending handshake to execute with and
@ -196,11 +202,11 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
* set the I/O timeout to the frontend's client timeout. * set the I/O timeout to the frontend's client timeout.
*/ */
if (s->si[0].conn.flags & CO_FL_HANDSHAKE) { if (s->si[0].conn->flags & CO_FL_HANDSHAKE) {
t->process = expire_mini_session; t->process = expire_mini_session;
t->expire = tick_add_ifset(now_ms, p->timeout.client); t->expire = tick_add_ifset(now_ms, p->timeout.client);
task_queue(t); task_queue(t);
s->si[0].conn.flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA; s->si[0].conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA;
return 1; return 1;
} }
@ -216,6 +222,10 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
p->feconn--; p->feconn--;
if (s->stkctr1_entry || s->stkctr2_entry) if (s->stkctr1_entry || s->stkctr2_entry)
session_store_counters(s); session_store_counters(s);
pool_free2(pool2_connection, s->si[1].conn);
out_fail_conn1:
pool_free2(pool2_connection, s->si[0].conn);
out_fail_conn0:
pool_free2(pool2_session, s); pool_free2(pool2_session, s);
out_close: out_close:
if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) { if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
@ -238,7 +248,7 @@ int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
static void kill_mini_session(struct session *s) static void kill_mini_session(struct session *s)
{ {
/* kill the connection now */ /* kill the connection now */
conn_xprt_close(&s->si[0].conn); conn_xprt_close(s->si[0].conn);
s->fe->feconn--; s->fe->feconn--;
if (s->stkctr1_entry || s->stkctr2_entry) if (s->stkctr1_entry || s->stkctr2_entry)
@ -262,11 +272,13 @@ static void kill_mini_session(struct session *s)
task_delete(s->task); task_delete(s->task);
task_free(s->task); task_free(s->task);
if (fdtab[s->si[0].conn.t.sock.fd].owner) if (fdtab[s->si[0].conn->t.sock.fd].owner)
fd_delete(s->si[0].conn.t.sock.fd); fd_delete(s->si[0].conn->t.sock.fd);
else else
close(s->si[0].conn.t.sock.fd); close(s->si[0].conn->t.sock.fd);
pool_free2(pool2_connection, s->si[1].conn);
pool_free2(pool2_connection, s->si[0].conn);
pool_free2(pool2_session, s); pool_free2(pool2_session, s);
} }
@ -393,8 +405,8 @@ int session_complete(struct session *s)
/* pre-initialize the other side's stream interface to an INIT state. The /* pre-initialize the other side's stream interface to an INIT state. The
* callbacks will be initialized before attempting to connect. * callbacks will be initialized before attempting to connect.
*/ */
s->si[1].conn.t.sock.fd = -1; /* just to help with debugging */ s->si[1].conn->t.sock.fd = -1; /* just to help with debugging */
s->si[1].conn.flags = CO_FL_NONE; s->si[1].conn->flags = CO_FL_NONE;
s->si[1].owner = t; s->si[1].owner = t;
s->si[1].state = s->si[1].prev_state = SI_ST_INI; s->si[1].state = s->si[1].prev_state = SI_ST_INI;
s->si[1].err_type = SI_ET_NONE; s->si[1].err_type = SI_ET_NONE;
@ -402,7 +414,7 @@ int session_complete(struct session *s)
s->si[1].err_loc = NULL; s->si[1].err_loc = NULL;
s->si[1].release = NULL; s->si[1].release = NULL;
s->si[1].send_proxy_ofs = 0; s->si[1].send_proxy_ofs = 0;
clear_target(&s->si[1].conn.target); clear_target(&s->si[1].conn->target);
si_prepare_embedded(&s->si[1]); si_prepare_embedded(&s->si[1]);
s->si[1].exp = TICK_ETERNITY; s->si[1].exp = TICK_ETERNITY;
s->si[1].flags = SI_FL_NONE; s->si[1].flags = SI_FL_NONE;
@ -485,7 +497,7 @@ int session_complete(struct session *s)
txn->rsp.chn = s->rep; txn->rsp.chn = s->rep;
/* finish initialization of the accepted file descriptor */ /* finish initialization of the accepted file descriptor */
conn_data_want_recv(&s->si[0].conn); conn_data_want_recv(s->si[0].conn);
if (p->accept && (ret = p->accept(s)) <= 0) { if (p->accept && (ret = p->accept(s)) <= 0) {
/* Either we had an unrecoverable error (<0) or work is /* Either we had an unrecoverable error (<0) or work is
@ -497,10 +509,10 @@ int session_complete(struct session *s)
/* if logs require transport layer information, note it on the connection */ /* if logs require transport layer information, note it on the connection */
if (s->logs.logwait & LW_XPRT) if (s->logs.logwait & LW_XPRT)
s->si[0].conn.flags |= CO_FL_XPRT_TRACKED; s->si[0].conn->flags |= CO_FL_XPRT_TRACKED;
/* we want the connection handler to notify the stream interface about updates. */ /* we want the connection handler to notify the stream interface about updates. */
s->si[0].conn.flags |= CO_FL_WAKE_DATA; s->si[0].conn->flags |= CO_FL_WAKE_DATA;
/* it is important not to call the wakeup function directly but to /* it is important not to call the wakeup function directly but to
* pass through task_wakeup(), because this one knows how to apply * pass through task_wakeup(), because this one knows how to apply
@ -572,8 +584,8 @@ static void session_free(struct session *s)
http_end_txn(s); http_end_txn(s);
/* ensure the client-side transport layer is destroyed */ /* ensure the client-side transport layer is destroyed */
s->si[0].conn.flags &= ~CO_FL_XPRT_TRACKED; s->si[0].conn->flags &= ~CO_FL_XPRT_TRACKED;
conn_xprt_close(&s->si[0].conn); conn_xprt_close(s->si[0].conn);
for (i = 0; i < s->store_count; i++) { for (i = 0; i < s->store_count; i++) {
if (!s->store[i].ts) if (!s->store[i].ts)
@ -602,6 +614,8 @@ static void session_free(struct session *s)
bref->ref = s->list.n; bref->ref = s->list.n;
} }
LIST_DEL(&s->list); LIST_DEL(&s->list);
pool_free2(pool2_connection, s->si[1].conn);
pool_free2(pool2_connection, s->si[0].conn);
pool_free2(pool2_session, s); pool_free2(pool2_session, s);
/* We may want to free the maximum amount of pools if the proxy is stopping */ /* We may want to free the maximum amount of pools if the proxy is stopping */
@ -752,7 +766,7 @@ static int sess_update_st_con_tcp(struct session *s, struct stream_interface *si
si->state = SI_ST_CER; si->state = SI_ST_CER;
fd_delete(si_fd(si)); fd_delete(si_fd(si));
conn_xprt_close(&si->conn); conn_xprt_close(si->conn);
if (si->release) if (si->release)
si->release(si); si->release(si);
@ -2069,8 +2083,8 @@ struct task *process_session(struct task *t)
if (!(s->req->flags & (CF_KERN_SPLICING|CF_SHUTR)) && if (!(s->req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
s->req->to_forward && s->req->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) && (global.tune.options & GTUNE_USE_SPLICE) &&
(s->si[0].conn.xprt && s->si[0].conn.xprt->rcv_pipe && s->si[0].conn.xprt->snd_pipe) && (s->si[0].conn->xprt && s->si[0].conn->xprt->rcv_pipe && s->si[0].conn->xprt->snd_pipe) &&
(s->si[1].conn.xprt && s->si[1].conn.xprt->rcv_pipe && s->si[1].conn.xprt->snd_pipe) && (s->si[1].conn->xprt && s->si[1].conn->xprt->rcv_pipe && s->si[1].conn->xprt->snd_pipe) &&
(pipes_used < global.maxpipes) && (pipes_used < global.maxpipes) &&
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) || (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) && (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
@ -2124,7 +2138,7 @@ struct task *process_session(struct task *t)
*/ */
s->req->cons->state = SI_ST_REQ; /* new connection requested */ s->req->cons->state = SI_ST_REQ; /* new connection requested */
s->req->cons->conn_retries = s->be->conn_retries; s->req->cons->conn_retries = s->be->conn_retries;
if (unlikely(s->req->cons->conn.target.type == TARG_TYPE_APPLET && if (unlikely(s->req->cons->conn->target.type == TARG_TYPE_APPLET &&
!(si_ctrl(s->req->cons) && si_ctrl(s->req->cons)->connect))) { !(si_ctrl(s->req->cons) && si_ctrl(s->req->cons)->connect))) {
s->req->cons->state = SI_ST_EST; /* connection established */ s->req->cons->state = SI_ST_EST; /* connection established */
s->rep->flags |= CF_READ_ATTACHED; /* producer is now attached */ s->rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
@ -2215,8 +2229,8 @@ struct task *process_session(struct task *t)
if (!(s->rep->flags & (CF_KERN_SPLICING|CF_SHUTR)) && if (!(s->rep->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
s->rep->to_forward && s->rep->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) && (global.tune.options & GTUNE_USE_SPLICE) &&
(s->si[0].conn.xprt && s->si[0].conn.xprt->rcv_pipe && s->si[0].conn.xprt->snd_pipe) && (s->si[0].conn->xprt && s->si[0].conn->xprt->rcv_pipe && s->si[0].conn->xprt->snd_pipe) &&
(s->si[1].conn.xprt && s->si[1].conn.xprt->rcv_pipe && s->si[1].conn.xprt->snd_pipe) && (s->si[1].conn->xprt && s->si[1].conn->xprt->rcv_pipe && s->si[1].conn->xprt->snd_pipe) &&
(pipes_used < global.maxpipes) && (pipes_used < global.maxpipes) &&
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) || (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) && (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
@ -2305,10 +2319,10 @@ struct task *process_session(struct task *t)
if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED)) if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
session_process_counters(s); session_process_counters(s);
if (s->rep->cons->state == SI_ST_EST && s->rep->cons->conn.target.type != TARG_TYPE_APPLET) if (s->rep->cons->state == SI_ST_EST && s->rep->cons->conn->target.type != TARG_TYPE_APPLET)
si_update(s->rep->cons); si_update(s->rep->cons);
if (s->req->cons->state == SI_ST_EST && s->req->cons->conn.target.type != TARG_TYPE_APPLET) if (s->req->cons->state == SI_ST_EST && s->req->cons->conn->target.type != TARG_TYPE_APPLET)
si_update(s->req->cons); si_update(s->req->cons);
s->req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED); s->req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
@ -2335,12 +2349,12 @@ struct task *process_session(struct task *t)
/* Call the stream interfaces' I/O handlers when embedded. /* Call the stream interfaces' I/O handlers when embedded.
* Note that this one may wake the task up again. * Note that this one may wake the task up again.
*/ */
if (s->req->cons->conn.target.type == TARG_TYPE_APPLET || if (s->req->cons->conn->target.type == TARG_TYPE_APPLET ||
s->rep->cons->conn.target.type == TARG_TYPE_APPLET) { s->rep->cons->conn->target.type == TARG_TYPE_APPLET) {
if (s->req->cons->conn.target.type == TARG_TYPE_APPLET) if (s->req->cons->conn->target.type == TARG_TYPE_APPLET)
s->req->cons->conn.target.ptr.a->fct(s->req->cons); s->req->cons->conn->target.ptr.a->fct(s->req->cons);
if (s->rep->cons->conn.target.type == TARG_TYPE_APPLET) if (s->rep->cons->conn->target.type == TARG_TYPE_APPLET)
s->rep->cons->conn.target.ptr.a->fct(s->rep->cons); s->rep->cons->conn->target.ptr.a->fct(s->rep->cons);
if (task_in_rq(t)) { if (task_in_rq(t)) {
/* If we woke up, we don't want to requeue the /* If we woke up, we don't want to requeue the
* task to the wait queue, but rather requeue * task to the wait queue, but rather requeue
@ -2577,7 +2591,7 @@ acl_fetch_src_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2637,7 +2651,7 @@ acl_fetch_src_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2698,7 +2712,7 @@ acl_fetch_src_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2754,7 +2768,7 @@ acl_fetch_src_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2815,7 +2829,7 @@ acl_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2835,7 +2849,7 @@ acl_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsi
struct stktable_key *key; struct stktable_key *key;
void *ptr; void *ptr;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2904,7 +2918,7 @@ acl_fetch_src_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -2960,7 +2974,7 @@ acl_fetch_src_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3021,7 +3035,7 @@ acl_fetch_src_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3077,7 +3091,7 @@ acl_fetch_src_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsig
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3138,7 +3152,7 @@ acl_fetch_src_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsi
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3194,7 +3208,7 @@ acl_fetch_src_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsig
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3255,7 +3269,7 @@ acl_fetch_src_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsi
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3316,7 +3330,7 @@ acl_fetch_src_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3379,7 +3393,7 @@ acl_fetch_src_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsi
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3440,7 +3454,7 @@ acl_fetch_src_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigne
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;
@ -3503,7 +3517,7 @@ acl_fetch_src_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, uns
{ {
struct stktable_key *key; struct stktable_key *key;
key = addr_to_stktable_key(&l4->si[0].conn.addr.from); key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
if (!key) if (!key)
return 0; return 0;

164
src/ssl_sock.c
View File

@ -1281,17 +1281,17 @@ static int
smp_fetch_ssl_fc_has_crt(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_ssl_fc_has_crt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
smp->flags = 0; smp->flags = 0;
smp->type = SMP_T_BOOL; smp->type = SMP_T_BOOL;
smp->data.uint = SSL_SOCK_ST_FL_VERIFY_DONE & l4->si[0].conn.xprt_st ? 1 : 0; smp->data.uint = SSL_SOCK_ST_FL_VERIFY_DONE & l4->si[0].conn->xprt_st ? 1 : 0;
return 1; return 1;
} }
@ -1305,16 +1305,16 @@ smp_fetch_ssl_c_serial(struct proxy *px, struct session *l4, void *l7, unsigned
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate, it increase X509 * ref count */ /* SSL_get_peer_certificate, it increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1340,16 +1340,16 @@ smp_fetch_ssl_c_notafter(struct proxy *px, struct session *l4, void *l7, unsigne
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate, it increase X509 * ref count */ /* SSL_get_peer_certificate, it increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1376,16 +1376,16 @@ smp_fetch_ssl_c_i_dn(struct proxy *px, struct session *l4, void *l7, unsigned in
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate, it increase X509 * ref count */ /* SSL_get_peer_certificate, it increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1426,16 +1426,16 @@ smp_fetch_ssl_c_notbefore(struct proxy *px, struct session *l4, void *l7, unsign
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate, it increase X509 * ref count */ /* SSL_get_peer_certificate, it increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1462,16 +1462,16 @@ smp_fetch_ssl_c_s_dn(struct proxy *px, struct session *l4, void *l7, unsigned in
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate, it increase X509 * ref count */ /* SSL_get_peer_certificate, it increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1509,16 +1509,16 @@ smp_fetch_ssl_c_version(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
X509 *crt; X509 *crt;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate returns a ptr on allocated X509 struct */ /* SSL_get_peer_certificate returns a ptr on allocated X509 struct */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
return 0; return 0;
@ -1537,16 +1537,16 @@ smp_fetch_ssl_c_sig_alg(struct proxy *px, struct session *l4, void *l7, unsigned
X509 *crt; X509 *crt;
int nid; int nid;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate increase X509 * ref count */ /* SSL_get_peer_certificate increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
return 0; return 0;
@ -1571,16 +1571,16 @@ smp_fetch_ssl_c_key_alg(struct proxy *px, struct session *l4, void *l7, unsigned
X509 *crt; X509 *crt;
int nid; int nid;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_peer_certificate increase X509 * ref count */ /* SSL_get_peer_certificate increase X509 * ref count */
crt = SSL_get_peer_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_peer_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
return 0; return 0;
@ -1603,7 +1603,7 @@ smp_fetch_ssl_fc(struct proxy *px, struct session *l4, void *l7, unsigned int op
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
smp->type = SMP_T_BOOL; smp->type = SMP_T_BOOL;
smp->data.uint = (l4->si[0].conn.xprt == &ssl_sock); smp->data.uint = (l4->si[0].conn->xprt == &ssl_sock);
return 1; return 1;
} }
@ -1614,9 +1614,9 @@ smp_fetch_ssl_fc_has_sni(struct proxy *px, struct session *l4, void *l7, unsigne
{ {
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
smp->type = SMP_T_BOOL; smp->type = SMP_T_BOOL;
smp->data.uint = (l4->si[0].conn.xprt == &ssl_sock) && smp->data.uint = (l4->si[0].conn->xprt == &ssl_sock) &&
l4->si[0].conn.xprt_ctx && l4->si[0].conn->xprt_ctx &&
SSL_get_servername(l4->si[0].conn.xprt_ctx, TLSEXT_NAMETYPE_host_name) != NULL; SSL_get_servername(l4->si[0].conn->xprt_ctx, TLSEXT_NAMETYPE_host_name) != NULL;
return 1; return 1;
#else #else
return 0; return 0;
@ -1632,15 +1632,15 @@ smp_fetch_ssl_f_serial(struct proxy *px, struct session *l4, void *l7, unsigned
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1663,15 +1663,15 @@ smp_fetch_ssl_f_notafter(struct proxy *px, struct session *l4, void *l7, unsigne
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1695,15 +1695,15 @@ smp_fetch_ssl_f_notbefore(struct proxy *px, struct session *l4, void *l7, unsign
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1725,16 +1725,16 @@ smp_fetch_ssl_f_version(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
X509 *crt; X509 *crt;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
/* SSL_get_certificate returns a ptr on an SSL * internal sub struct */ /* SSL_get_certificate returns a ptr on an SSL * internal sub struct */
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
return 0; return 0;
@ -1752,15 +1752,15 @@ smp_fetch_ssl_f_sig_alg(struct proxy *px, struct session *l4, void *l7, unsigned
X509 *crt; X509 *crt;
int nid; int nid;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
return 0; return 0;
@ -1784,15 +1784,15 @@ smp_fetch_ssl_f_key_alg(struct proxy *px, struct session *l4, void *l7, unsigned
X509 *crt; X509 *crt;
int nid; int nid;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
return 0; return 0;
@ -1818,15 +1818,15 @@ smp_fetch_ssl_f_i_dn(struct proxy *px, struct session *l4, void *l7, unsigned in
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1866,15 +1866,15 @@ smp_fetch_ssl_f_s_dn(struct proxy *px, struct session *l4, void *l7, unsigned in
int ret = 0; int ret = 0;
struct chunk *smp_trash; struct chunk *smp_trash;
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags |= SMP_F_MAY_CHANGE; smp->flags |= SMP_F_MAY_CHANGE;
return 0; return 0;
} }
crt = SSL_get_certificate(l4->si[0].conn.xprt_ctx); crt = SSL_get_certificate(l4->si[0].conn->xprt_ctx);
if (!crt) if (!crt)
goto out; goto out;
@ -1910,10 +1910,10 @@ smp_fetch_ssl_fc_cipher(struct proxy *px, struct session *l4, void *l7, unsigned
{ {
smp->flags = 0; smp->flags = 0;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
smp->data.str.str = (char *)SSL_get_cipher_name(l4->si[0].conn.xprt_ctx); smp->data.str.str = (char *)SSL_get_cipher_name(l4->si[0].conn->xprt_ctx);
if (!smp->data.str.str) if (!smp->data.str.str)
return 0; return 0;
@ -1929,10 +1929,10 @@ smp_fetch_ssl_fc_alg_keysize(struct proxy *px, struct session *l4, void *l7, uns
{ {
smp->flags = 0; smp->flags = 0;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!SSL_get_cipher_bits(l4->si[0].conn.xprt_ctx, (int *)&smp->data.uint)) if (!SSL_get_cipher_bits(l4->si[0].conn->xprt_ctx, (int *)&smp->data.uint))
return 0; return 0;
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
@ -1946,10 +1946,10 @@ smp_fetch_ssl_fc_use_keysize(struct proxy *px, struct session *l4, void *l7, uns
{ {
smp->flags = 0; smp->flags = 0;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
smp->data.uint = (unsigned int)SSL_get_cipher_bits(l4->si[0].conn.xprt_ctx, NULL); smp->data.uint = (unsigned int)SSL_get_cipher_bits(l4->si[0].conn->xprt_ctx, NULL);
if (!smp->data.uint) if (!smp->data.uint)
return 0; return 0;
@ -1966,11 +1966,11 @@ smp_fetch_ssl_fc_npn(struct proxy *px, struct session *l4, void *l7, unsigned in
smp->flags = 0; smp->flags = 0;
smp->type = SMP_T_CSTR; smp->type = SMP_T_CSTR;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
smp->data.str.str = NULL; smp->data.str.str = NULL;
SSL_get0_next_proto_negotiated(l4->si[0].conn.xprt_ctx, SSL_get0_next_proto_negotiated(l4->si[0].conn->xprt_ctx,
(const unsigned char **)&smp->data.str.str, (unsigned *)&smp->data.str.len); (const unsigned char **)&smp->data.str.str, (unsigned *)&smp->data.str.len);
if (!smp->data.str.str) if (!smp->data.str.str)
@ -1986,10 +1986,10 @@ smp_fetch_ssl_fc_protocol(struct proxy *px, struct session *l4, void *l7, unsign
{ {
smp->flags = 0; smp->flags = 0;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
smp->data.str.str = (char *)SSL_get_version(l4->si[0].conn.xprt_ctx); smp->data.str.str = (char *)SSL_get_version(l4->si[0].conn->xprt_ctx);
if (!smp->data.str.str) if (!smp->data.str.str)
return 0; return 0;
@ -2009,10 +2009,10 @@ smp_fetch_ssl_fc_session_id(struct proxy *px, struct session *l4, void *l7, unsi
smp->flags = 0; smp->flags = 0;
smp->type = SMP_T_CBIN; smp->type = SMP_T_CBIN;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
sess = SSL_get_session(l4->si[0].conn.xprt_ctx); sess = SSL_get_session(l4->si[0].conn->xprt_ctx);
if (!sess) if (!sess)
return 0; return 0;
@ -2034,10 +2034,10 @@ smp_fetch_ssl_fc_sni(struct proxy *px, struct session *l4, void *l7, unsigned in
smp->flags = 0; smp->flags = 0;
smp->type = SMP_T_CSTR; smp->type = SMP_T_CSTR;
if (!l4 || !l4->si[0].conn.xprt_ctx || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || !l4->si[0].conn->xprt_ctx || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
smp->data.str.str = (char *)SSL_get_servername(l4->si[0].conn.xprt_ctx, TLSEXT_NAMETYPE_host_name); smp->data.str.str = (char *)SSL_get_servername(l4->si[0].conn->xprt_ctx, TLSEXT_NAMETYPE_host_name);
if (!smp->data.str.str) if (!smp->data.str.str)
return 0; return 0;
@ -2053,16 +2053,16 @@ static int
smp_fetch_ssl_c_ca_err(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_ssl_c_ca_err(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags = SMP_F_MAY_CHANGE; smp->flags = SMP_F_MAY_CHANGE;
return 0; return 0;
} }
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
smp->data.uint = (unsigned int)SSL_SOCK_ST_TO_CA_ERROR(l4->si[0].conn.xprt_st); smp->data.uint = (unsigned int)SSL_SOCK_ST_TO_CA_ERROR(l4->si[0].conn->xprt_st);
smp->flags = 0; smp->flags = 0;
return 1; return 1;
@ -2073,16 +2073,16 @@ static int
smp_fetch_ssl_c_ca_err_depth(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_ssl_c_ca_err_depth(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags = SMP_F_MAY_CHANGE; smp->flags = SMP_F_MAY_CHANGE;
return 0; return 0;
} }
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
smp->data.uint = (unsigned int)SSL_SOCK_ST_TO_CAEDEPTH(l4->si[0].conn.xprt_st); smp->data.uint = (unsigned int)SSL_SOCK_ST_TO_CAEDEPTH(l4->si[0].conn->xprt_st);
smp->flags = 0; smp->flags = 0;
return 1; return 1;
@ -2093,16 +2093,16 @@ static int
smp_fetch_ssl_c_err(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_ssl_c_err(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags = SMP_F_MAY_CHANGE; smp->flags = SMP_F_MAY_CHANGE;
return 0; return 0;
} }
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
smp->data.uint = (unsigned int)SSL_SOCK_ST_TO_CRTERROR(l4->si[0].conn.xprt_st); smp->data.uint = (unsigned int)SSL_SOCK_ST_TO_CRTERROR(l4->si[0].conn->xprt_st);
smp->flags = 0; smp->flags = 0;
return 1; return 1;
@ -2113,19 +2113,19 @@ static int
smp_fetch_ssl_c_verify(struct proxy *px, struct session *l4, void *l7, unsigned int opt, smp_fetch_ssl_c_verify(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
const struct arg *args, struct sample *smp) const struct arg *args, struct sample *smp)
{ {
if (!l4 || l4->si[0].conn.xprt != &ssl_sock) if (!l4 || l4->si[0].conn->xprt != &ssl_sock)
return 0; return 0;
if (!(l4->si[0].conn.flags & CO_FL_CONNECTED)) { if (!(l4->si[0].conn->flags & CO_FL_CONNECTED)) {
smp->flags = SMP_F_MAY_CHANGE; smp->flags = SMP_F_MAY_CHANGE;
return 0; return 0;
} }
if (!l4->si[0].conn.xprt_ctx) if (!l4->si[0].conn->xprt_ctx)
return 0; return 0;
smp->type = SMP_T_UINT; smp->type = SMP_T_UINT;
smp->data.uint = (unsigned int)SSL_get_verify_result(l4->si[0].conn.xprt_ctx); smp->data.uint = (unsigned int)SSL_get_verify_result(l4->si[0].conn->xprt_ctx);
smp->flags = 0; smp->flags = 0;
return 1; return 1;

56
src/stream_interface.c
View File

@ -233,7 +233,7 @@ static void stream_int_update_embedded(struct stream_interface *si)
*/ */
int stream_int_shutr(struct stream_interface *si) int stream_int_shutr(struct stream_interface *si)
{ {
struct connection *conn = &si->conn; struct connection *conn = si->conn;
si->ib->flags &= ~CF_SHUTR_NOW; si->ib->flags &= ~CF_SHUTR_NOW;
if (si->ib->flags & CF_SHUTR) if (si->ib->flags & CF_SHUTR)
@ -246,7 +246,7 @@ int stream_int_shutr(struct stream_interface *si)
return 0; return 0;
if (si->ob->flags & CF_SHUTW) { if (si->ob->flags & CF_SHUTW) {
conn_xprt_close(&si->conn); conn_xprt_close(si->conn);
if (conn->ctrl) if (conn->ctrl)
fd_delete(si_fd(si)); fd_delete(si_fd(si));
si->state = SI_ST_DIS; si->state = SI_ST_DIS;
@ -284,7 +284,7 @@ int stream_int_shutr(struct stream_interface *si)
*/ */
int stream_int_shutw(struct stream_interface *si) int stream_int_shutw(struct stream_interface *si)
{ {
struct connection *conn = &si->conn; struct connection *conn = si->conn;
si->ob->flags &= ~CF_SHUTW_NOW; si->ob->flags &= ~CF_SHUTW_NOW;
if (si->ob->flags & CF_SHUTW) if (si->ob->flags & CF_SHUTW)
@ -337,7 +337,7 @@ int stream_int_shutw(struct stream_interface *si)
/* we may have to close a pending connection, and mark the /* we may have to close a pending connection, and mark the
* response buffer as shutr * response buffer as shutr
*/ */
conn_xprt_close(&si->conn); conn_xprt_close(si->conn);
if (conn->ctrl) if (conn->ctrl)
fd_delete(si_fd(si)); fd_delete(si_fd(si));
/* fall through */ /* fall through */
@ -425,7 +425,7 @@ struct task *stream_int_register_handler(struct stream_interface *si, struct si_
DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", app, si, si->owner); DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", app, si, si->owner);
si_prepare_embedded(si); si_prepare_embedded(si);
set_target_applet(&si->conn.target, app); set_target_applet(&si->conn->target, app);
si->release = app->release; si->release = app->release;
si->flags |= SI_FL_WAIT_DATA; si->flags |= SI_FL_WAIT_DATA;
return si->owner; return si->owner;
@ -446,7 +446,7 @@ struct task *stream_int_register_handler_task(struct stream_interface *si,
DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", fct, si, si->owner); DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", fct, si, si->owner);
si_prepare_task(si); si_prepare_task(si);
clear_target(&si->conn.target); clear_target(&si->conn->target);
si->release = NULL; si->release = NULL;
si->flags |= SI_FL_WAIT_DATA; si->flags |= SI_FL_WAIT_DATA;
@ -455,7 +455,7 @@ struct task *stream_int_register_handler_task(struct stream_interface *si,
if (!t) if (!t)
return t; return t;
set_target_task(&si->conn.target, t); set_target_task(&si->conn->target, t);
t->process = fct; t->process = fct;
t->context = si; t->context = si;
@ -470,14 +470,14 @@ struct task *stream_int_register_handler_task(struct stream_interface *si,
*/ */
void stream_int_unregister_handler(struct stream_interface *si) void stream_int_unregister_handler(struct stream_interface *si)
{ {
if (si->conn.target.type == TARG_TYPE_TASK) { if (si->conn->target.type == TARG_TYPE_TASK) {
/* external handler : kill the task */ /* external handler : kill the task */
task_delete(si->conn.target.ptr.t); task_delete(si->conn->target.ptr.t);
task_free(si->conn.target.ptr.t); task_free(si->conn->target.ptr.t);
} }
si->release = NULL; si->release = NULL;
si->owner = NULL; si->owner = NULL;
clear_target(&si->conn.target); clear_target(&si->conn->target);
} }
/* This callback is used to send a valid PROXY protocol line to a socket being /* This callback is used to send a valid PROXY protocol line to a socket being
@ -507,7 +507,7 @@ int conn_si_send_proxy(struct connection *conn, unsigned int flag)
* (which is recomputed every time since it's constant). If * (which is recomputed every time since it's constant). If
* it is positive, it means we have to send from the start. * it is positive, it means we have to send from the start.
*/ */
ret = make_proxy_line(trash, global.tune.bufsize, &si->ob->prod->conn.addr.from, &si->ob->prod->conn.addr.to); ret = make_proxy_line(trash, global.tune.bufsize, &si->ob->prod->conn->addr.from, &si->ob->prod->conn->addr.to);
if (!ret) if (!ret)
goto out_error; goto out_error;
@ -759,7 +759,7 @@ void stream_int_update_conn(struct stream_interface *si)
if (!(si->flags & SI_FL_WAIT_ROOM)) { if (!(si->flags & SI_FL_WAIT_ROOM)) {
if (!(ib->flags & (CF_HIJACK|CF_DONT_READ))) /* full */ if (!(ib->flags & (CF_HIJACK|CF_DONT_READ))) /* full */
si->flags |= SI_FL_WAIT_ROOM; si->flags |= SI_FL_WAIT_ROOM;
conn_data_stop_recv(&si->conn); conn_data_stop_recv(si->conn);
ib->rex = TICK_ETERNITY; ib->rex = TICK_ETERNITY;
} }
} }
@ -770,7 +770,7 @@ void stream_int_update_conn(struct stream_interface *si)
* have updated it if there has been a completed I/O. * have updated it if there has been a completed I/O.
*/ */
si->flags &= ~SI_FL_WAIT_ROOM; si->flags &= ~SI_FL_WAIT_ROOM;
conn_data_want_recv(&si->conn); conn_data_want_recv(si->conn);
if (!(ib->flags & (CF_READ_NOEXP|CF_DONT_READ)) && !tick_isset(ib->rex)) if (!(ib->flags & (CF_READ_NOEXP|CF_DONT_READ)) && !tick_isset(ib->rex))
ib->rex = tick_add_ifset(now_ms, ib->rto); ib->rex = tick_add_ifset(now_ms, ib->rto);
} }
@ -784,7 +784,7 @@ void stream_int_update_conn(struct stream_interface *si)
if (!(si->flags & SI_FL_WAIT_DATA)) { if (!(si->flags & SI_FL_WAIT_DATA)) {
if ((ob->flags & (CF_HIJACK|CF_SHUTW_NOW)) == 0) if ((ob->flags & (CF_HIJACK|CF_SHUTW_NOW)) == 0)
si->flags |= SI_FL_WAIT_DATA; si->flags |= SI_FL_WAIT_DATA;
conn_data_stop_send(&si->conn); conn_data_stop_send(si->conn);
ob->wex = TICK_ETERNITY; ob->wex = TICK_ETERNITY;
} }
} }
@ -795,7 +795,7 @@ void stream_int_update_conn(struct stream_interface *si)
* have updated it if there has been a completed I/O. * have updated it if there has been a completed I/O.
*/ */
si->flags &= ~SI_FL_WAIT_DATA; si->flags &= ~SI_FL_WAIT_DATA;
conn_data_want_send(&si->conn); conn_data_want_send(si->conn);
if (!tick_isset(ob->wex)) { if (!tick_isset(ob->wex)) {
ob->wex = tick_add_ifset(now_ms, ob->wto); ob->wex = tick_add_ifset(now_ms, ob->wto);
if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) { if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
@ -829,12 +829,12 @@ static void stream_int_chk_rcv_conn(struct stream_interface *si)
/* stop reading */ /* stop reading */
if (!(ib->flags & (CF_HIJACK|CF_DONT_READ))) /* full */ if (!(ib->flags & (CF_HIJACK|CF_DONT_READ))) /* full */
si->flags |= SI_FL_WAIT_ROOM; si->flags |= SI_FL_WAIT_ROOM;
conn_data_stop_recv(&si->conn); conn_data_stop_recv(si->conn);
} }
else { else {
/* (re)start reading */ /* (re)start reading */
si->flags &= ~SI_FL_WAIT_ROOM; si->flags &= ~SI_FL_WAIT_ROOM;
conn_data_want_recv(&si->conn); conn_data_want_recv(si->conn);
} }
} }
@ -859,14 +859,14 @@ static void stream_int_chk_snd_conn(struct stream_interface *si)
(fdtab[si_fd(si)].ev & FD_POLL_OUT))) /* we'll be called anyway */ (fdtab[si_fd(si)].ev & FD_POLL_OUT))) /* we'll be called anyway */
return; return;
if (!(si->conn.flags & CO_FL_HANDSHAKE) && si_conn_send_loop(&si->conn) < 0) { if (!(si->conn->flags & CO_FL_HANDSHAKE) && si_conn_send_loop(si->conn) < 0) {
/* Write error on the file descriptor. We mark the FD as STERROR so /* 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. * that we don't use it anymore and we notify the task.
*/ */
fdtab[si_fd(si)].ev &= ~FD_POLL_STICKY; fdtab[si_fd(si)].ev &= ~FD_POLL_STICKY;
__conn_data_stop_both(&si->conn); __conn_data_stop_both(si->conn);
si->flags |= SI_FL_ERR; si->flags |= SI_FL_ERR;
si->conn.flags |= CO_FL_ERROR; si->conn->flags |= CO_FL_ERROR;
goto out_wakeup; goto out_wakeup;
} }
@ -894,7 +894,7 @@ static void stream_int_chk_snd_conn(struct stream_interface *si)
/* Otherwise there are remaining data to be sent in the buffer, /* Otherwise there are remaining data to be sent in the buffer,
* which means we have to poll before doing so. * which means we have to poll before doing so.
*/ */
__conn_data_want_send(&si->conn); __conn_data_want_send(si->conn);
si->flags &= ~SI_FL_WAIT_DATA; si->flags &= ~SI_FL_WAIT_DATA;
if (!tick_isset(ob->wex)) if (!tick_isset(ob->wex))
ob->wex = tick_add_ifset(now_ms, ob->wto); ob->wex = tick_add_ifset(now_ms, ob->wto);
@ -931,7 +931,7 @@ static void stream_int_chk_snd_conn(struct stream_interface *si)
} }
/* commit possible polling changes */ /* commit possible polling changes */
conn_cond_update_polling(&si->conn); conn_cond_update_polling(si->conn);
} }
/* /*
@ -1158,7 +1158,7 @@ static void si_conn_send_cb(struct connection *conn)
if (conn->flags & CO_FL_ERROR) if (conn->flags & CO_FL_ERROR)
goto out_error; goto out_error;
if (si->conn.flags & CO_FL_HANDSHAKE) if (si->conn->flags & CO_FL_HANDSHAKE)
/* a handshake was requested */ /* a handshake was requested */
return; return;
@ -1208,17 +1208,17 @@ void stream_sock_read0(struct stream_interface *si)
(struct linger *) &nolinger, sizeof(struct linger)); (struct linger *) &nolinger, sizeof(struct linger));
} }
/* force flag on ssl to keep session in cache */ /* force flag on ssl to keep session in cache */
if (si->conn.xprt->shutw) if (si->conn->xprt->shutw)
si->conn.xprt->shutw(&si->conn, 0); si->conn->xprt->shutw(si->conn, 0);
goto do_close; goto do_close;
} }
/* otherwise that's just a normal read shutdown */ /* otherwise that's just a normal read shutdown */
__conn_data_stop_recv(&si->conn); __conn_data_stop_recv(si->conn);
return; return;
do_close: do_close:
conn_xprt_close(&si->conn); conn_xprt_close(si->conn);
fd_delete(si_fd(si)); fd_delete(si_fd(si));
si->state = SI_ST_DIS; si->state = SI_ST_DIS;
si->exp = TICK_ETERNITY; si->exp = TICK_ETERNITY;