From d85c48589a8571fc37e1add39a046f6fb1f14fd3 Mon Sep 17 00:00:00 2001 From: Willy Tarreau Date: Fri, 13 Mar 2015 00:40:28 +0100 Subject: [PATCH] REORG: connection: move conn_drain() to connection.c and rename it It's now called conn_sock_drain() to make it clear that it only reads at the sock layer and not at the data layer. The function was too big to remain inlined and it's used at a few places where size counts. --- include/proto/connection.h | 39 +++----------------------------------- src/checks.c | 4 ++-- src/connection.c | 36 +++++++++++++++++++++++++++++++++++ src/ssl_sock.c | 4 ++-- src/stream_interface.c | 2 +- 5 files changed, 44 insertions(+), 41 deletions(-) diff --git a/include/proto/connection.h b/include/proto/connection.h index f542cb2db..2fb25cc29 100644 --- a/include/proto/connection.h +++ b/include/proto/connection.h @@ -48,6 +48,9 @@ int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connec /* raw send() directly on the socket */ int conn_sock_send(struct connection *conn, const void *buf, int len, int flags); +/* drains any pending bytes from the socket */ +int conn_sock_drain(struct connection *conn); + /* returns true is the transport layer is ready */ static inline int conn_xprt_ready(const struct connection *conn) { @@ -540,42 +543,6 @@ static inline void conn_attach(struct connection *conn, void *owner, const struc conn->owner = owner; } -/* Drains possibly pending incoming data on the file descriptor attached to the - * connection and update the connection's flags accordingly. This is used to - * know whether we need to disable lingering on close. Returns non-zero if it - * is safe to close without disabling lingering, otherwise zero. The SOCK_RD_SH - * flag may also be updated if the incoming shutdown was reported by the drain() - * function. - */ -static inline int conn_drain(struct connection *conn) -{ - if (!conn_ctrl_ready(conn)) - return 1; - - if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) - return 1; - - if (fdtab[conn->t.sock.fd].ev & (FD_POLL_ERR|FD_POLL_HUP)) { - fdtab[conn->t.sock.fd].linger_risk = 0; - } - else { - if (!fd_recv_ready(conn->t.sock.fd)) - return 0; - - /* disable draining if we were called and have no drain function */ - if (!conn->ctrl->drain) { - __conn_data_stop_recv(conn); - return 0; - } - - if (conn->ctrl->drain(conn->t.sock.fd) <= 0) - return 0; - } - - conn->flags |= CO_FL_SOCK_RD_SH; - return 1; -} - /* returns a human-readable error code for conn->err_code, or NULL if the code * is unknown. */ diff --git a/src/checks.c b/src/checks.c index f61bc9c78..2ef14d102 100644 --- a/src/checks.c +++ b/src/checks.c @@ -1340,7 +1340,7 @@ static int wake_srv_chk(struct connection *conn) /* We're here because nobody wants to handle the error, so we * sure want to abort the hard way. */ - conn_drain(conn); + conn_sock_drain(conn); conn_force_close(conn); } return 0; @@ -2079,7 +2079,7 @@ static struct task *process_chk_conn(struct task *t) * as a failed response coupled with "observe layer7" caused the * server state to be suddenly changed. */ - conn_drain(conn); + conn_sock_drain(conn); conn_force_close(conn); } diff --git a/src/connection.c b/src/connection.c index 8b3c835e7..efcd6e123 100644 --- a/src/connection.c +++ b/src/connection.c @@ -268,6 +268,42 @@ int conn_sock_send(struct connection *conn, const void *buf, int len, int flags) return ret; } +/* Drains possibly pending incoming data on the file descriptor attached to the + * connection and update the connection's flags accordingly. This is used to + * know whether we need to disable lingering on close. Returns non-zero if it + * is safe to close without disabling lingering, otherwise zero. The SOCK_RD_SH + * flag may also be updated if the incoming shutdown was reported by the drain() + * function. + */ +int conn_sock_drain(struct connection *conn) +{ + if (!conn_ctrl_ready(conn)) + return 1; + + if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) + return 1; + + if (fdtab[conn->t.sock.fd].ev & (FD_POLL_ERR|FD_POLL_HUP)) { + fdtab[conn->t.sock.fd].linger_risk = 0; + } + else { + if (!fd_recv_ready(conn->t.sock.fd)) + return 0; + + /* disable draining if we were called and have no drain function */ + if (!conn->ctrl->drain) { + __conn_data_stop_recv(conn); + return 0; + } + + if (conn->ctrl->drain(conn->t.sock.fd) <= 0) + return 0; + } + + conn->flags |= CO_FL_SOCK_RD_SH; + return 1; +} + /* * Get data length from tlv */ diff --git a/src/ssl_sock.c b/src/ssl_sock.c index bc2090890..77c44904d 100644 --- a/src/ssl_sock.c +++ b/src/ssl_sock.c @@ -2466,7 +2466,7 @@ int ssl_sock_handshake(struct connection *conn, unsigned int flag) * TCP sockets. We first try to drain possibly pending * data to avoid this as much as possible. */ - conn_drain(conn); + conn_sock_drain(conn); if (!conn->err_code) conn->err_code = (conn->xprt_st & SSL_SOCK_RECV_HEARTBEAT) ? CO_ER_SSL_KILLED_HB : CO_ER_SSL_HANDSHAKE; @@ -2532,7 +2532,7 @@ int ssl_sock_handshake(struct connection *conn, unsigned int flag) * TCP sockets. We first try to drain possibly pending * data to avoid this as much as possible. */ - conn_drain(conn); + conn_sock_drain(conn); if (!conn->err_code) conn->err_code = (conn->xprt_st & SSL_SOCK_RECV_HEARTBEAT) ? CO_ER_SSL_KILLED_HB : CO_ER_SSL_HANDSHAKE; diff --git a/src/stream_interface.c b/src/stream_interface.c index 8450117c2..1d8cec2fc 100644 --- a/src/stream_interface.c +++ b/src/stream_interface.c @@ -497,7 +497,7 @@ int conn_si_send_proxy(struct connection *conn, unsigned int flag) */ static void si_idle_conn_null_cb(struct connection *conn) { - conn_drain(conn); + conn_sock_drain(conn); } /* Callback to be used by connection I/O handlers when some activity is detected