From ba392cecf9537ab6ab224af033a663ffd9be1a87 Mon Sep 17 00:00:00 2001 From: Willy Tarreau Date: Sat, 16 Aug 2008 21:13:23 +0200 Subject: [PATCH] [CLEANUP] get rid of BF_SHUT*_PENDING BF_SHUTR_PENDING and BF_SHUTW_PENDING were poor ideas because BF_SHUTR is the pending of BF_SHUTW_DONE and BF_SHUTW is the pending of BF_SHUTR_DONE. Remove those two useless and confusing "pending" versions and rename buffer_shut{r,w}_* functions. --- include/proto/buffers.h | 25 ++------- include/types/buffers.h | 9 +--- src/proto_http.c | 112 ++++++++++++++++++++-------------------- src/proto_uxst.c | 40 +++++++------- src/stream_sock.c | 2 +- 5 files changed, 84 insertions(+), 104 deletions(-) diff --git a/include/proto/buffers.h b/include/proto/buffers.h index 7a4e0b03c..4090eade9 100644 --- a/include/proto/buffers.h +++ b/include/proto/buffers.h @@ -2,7 +2,7 @@ include/proto/buffers.h Buffer management definitions, macros and inline functions. - Copyright (C) 2000-2007 Willy Tarreau - w@1wt.eu + Copyright (C) 2000-2008 Willy Tarreau - w@1wt.eu This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -66,35 +66,20 @@ static inline void buffer_flush(struct buffer *buf) buf->l = 0; } -/* marks the buffer as "shutdown pending" for reads and cancels the timeout */ +/* marks the buffer as "shutdown" for reads and cancels the timeout */ static inline void buffer_shutr(struct buffer *buf) { buf->rex = TICK_ETERNITY; - buf->flags |= BF_SHUTR_PENDING; + buf->flags |= BF_SHUTR; } -/* marks the buffer as "shutdown done" for reads and cancels the timeout */ -static inline void buffer_shutr_done(struct buffer *buf) -{ - buf->rex = TICK_ETERNITY; - buf->flags |= BF_SHUTR_DONE; -} - -/* marks the buffer as "shutdown pending" for writes and cancels the timeout */ +/* marks the buffer as "shutdown" for writes and cancels the timeout */ static inline void buffer_shutw(struct buffer *buf) { buf->wex = TICK_ETERNITY; - buf->flags |= BF_SHUTW_PENDING; + buf->flags |= BF_SHUTW; } -/* marks the buffer as "shutdown done" for writes and cancels the timeout */ -static inline void buffer_shutw_done(struct buffer *buf) -{ - buf->wex = TICK_ETERNITY; - buf->flags |= BF_SHUTW_DONE; -} - - /* returns the maximum number of bytes writable at once in this buffer */ static inline int buffer_max(const struct buffer *buf) { diff --git a/include/types/buffers.h b/include/types/buffers.h index 83190104c..be9369358 100644 --- a/include/types/buffers.h +++ b/include/types/buffers.h @@ -28,13 +28,8 @@ /* The BF_* macros designate Buffer Flags, which may be ORed in the bit field * member 'flags' in struct buffer. */ -#define BF_SHUTR_PENDING 1 /* ignored if BF_SHUTW_DONE */ -#define BF_SHUTR_DONE 2 /* takes precedence over BF_SHUTR_PENDING */ -#define BF_SHUTR_STATUS (BF_SHUTR_PENDING|BF_SHUTR_DONE) - -#define BF_SHUTW_PENDING 4 /* ignored if BF_SHUTW_DONE */ -#define BF_SHUTW_DONE 8 /* takes precedence over BF_SHUTW_PENDING */ -#define BF_SHUTW_STATUS (BF_SHUTW_PENDING|BF_SHUTW_DONE) +#define BF_SHUTR 4 /* producer has already shut down */ +#define BF_SHUTW 8 /* consumer has already shut down */ #define BF_PARTIAL_READ 16 #define BF_COMPLETE_READ 32 diff --git a/src/proto_http.c b/src/proto_http.c index c4c527663..acbe5ddca 100644 --- a/src/proto_http.c +++ b/src/proto_http.c @@ -546,8 +546,8 @@ void srv_close_with_err(struct session *t, int err, int finst, { t->srv_state = SV_STCLOSE; t->rep->flags |= BF_MAY_FORWARD; - buffer_shutw_done(t->req); - buffer_shutr_done(t->rep); + buffer_shutw(t->req); + buffer_shutr(t->rep); if (status > 0 && msg) { t->txn.status = status; if (t->fe->mode == PR_MODE_HTTP) @@ -692,7 +692,7 @@ void process_session(struct task *t, int *next) * request timeout is set and the server has not yet sent a response. */ - if ((s->rep->flags & (BF_MAY_FORWARD|BF_SHUTR_STATUS)) == 0 && + if ((s->rep->flags & (BF_MAY_FORWARD|BF_SHUTR)) == 0 && (tick_isset(s->req->cex) || tick_isset(s->req->wex) || tick_isset(s->rep->rex))) s->req->rex = TICK_ETERNITY; @@ -1622,7 +1622,7 @@ int process_request(struct session *t) * - if one rule returns KO, then return KO */ - if (req->flags & (BF_READ_NULL | BF_SHUTR_STATUS) || + if (req->flags & (BF_READ_NULL | BF_SHUTR) || tick_is_expired(t->inspect_exp, now_ms)) partial = 0; else @@ -1649,8 +1649,8 @@ int process_request(struct session *t) if (ret) { /* we have a matching rule. */ if (rule->action == TCP_ACT_REJECT) { - buffer_shutr_done(req); - buffer_shutw_done(rep); + buffer_shutr(req); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; t->analysis &= ~AN_REQ_ANY; @@ -1781,7 +1781,7 @@ int process_request(struct session *t) } /* 4: have we encountered a read error or did we have to shutdown ? */ - else if (req->flags & (BF_READ_ERROR | BF_SHUTR_STATUS)) { + else if (req->flags & (BF_READ_ERROR | BF_SHUTR)) { /* we cannot return any message on error */ msg->msg_state = HTTP_MSG_ERROR; t->analysis &= ~AN_REQ_ANY; @@ -2594,8 +2594,8 @@ int process_response(struct session *t) /* Invalid response */ if (unlikely(msg->msg_state == HTTP_MSG_ERROR)) { hdr_response_bad: - buffer_shutr_done(rep); - buffer_shutw_done(req); + buffer_shutr(rep); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -2619,9 +2619,9 @@ int process_response(struct session *t) } /* write error to client, read error or close from server */ if (req->flags & BF_WRITE_ERROR || - rep->flags & (BF_READ_ERROR | BF_READ_NULL | BF_SHUTW_STATUS)) { - buffer_shutr_done(rep); - buffer_shutw_done(req); + rep->flags & (BF_READ_ERROR | BF_READ_NULL | BF_SHUTW)) { + buffer_shutr(rep); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -2649,8 +2649,8 @@ int process_response(struct session *t) } /* read timeout : return a 504 to the client. */ else if (rep->flags & BF_READ_TIMEOUT) { - buffer_shutr_done(rep); - buffer_shutw_done(req); + buffer_shutr(rep); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -2753,8 +2753,8 @@ int process_response(struct session *t) } cur_proxy->failed_resp++; return_srv_prx_502: - buffer_shutr_done(rep); - buffer_shutw_done(req); + buffer_shutr(rep); + buffer_shutw(req); fd_delete(t->srv_fd); t->srv_state = SV_STCLOSE; t->analysis &= ~AN_RTR_ANY; @@ -3011,8 +3011,8 @@ int process_cli(struct session *t) if (t->cli_state == CL_STDATA || t->cli_state == CL_STSHUTR) { /* read or write error */ if (rep->flags & BF_WRITE_ERROR || req->flags & BF_READ_ERROR) { - buffer_shutr_done(req); - buffer_shutw_done(rep); + buffer_shutr(req); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; trace_term(t, TT_HTTP_CLI_1); @@ -3031,10 +3031,10 @@ int process_cli(struct session *t) return 1; } /* last read, or end of server write */ - else if (!(req->flags & BF_SHUTR_STATUS) && /* already done */ - req->flags & (BF_READ_NULL | BF_SHUTW_STATUS)) { - buffer_shutr_done(req); - if (!(rep->flags & BF_SHUTW_STATUS)) { + else if (!(req->flags & BF_SHUTR) && /* already done */ + req->flags & (BF_READ_NULL | BF_SHUTW)) { + buffer_shutr(req); + if (!(rep->flags & BF_SHUTW)) { EV_FD_CLR(t->cli_fd, DIR_RD); trace_term(t, TT_HTTP_CLI_2); } else { @@ -3048,11 +3048,11 @@ int process_cli(struct session *t) /* last server read and buffer empty : we only check them when we're * allowed to forward the data. */ - else if (!(rep->flags & BF_SHUTW_STATUS) && /* already done */ + else if (!(rep->flags & BF_SHUTW) && /* already done */ rep->l == 0 && rep->flags & BF_MAY_FORWARD && - rep->flags & BF_SHUTR_STATUS && !(t->flags & SN_SELF_GEN)) { - buffer_shutw_done(rep); - if (!(req->flags & BF_SHUTR_STATUS)) { + rep->flags & BF_SHUTR && !(t->flags & SN_SELF_GEN)) { + buffer_shutw(rep); + if (!(req->flags & BF_SHUTR)) { EV_FD_CLR(t->cli_fd, DIR_WR); shutdown(t->cli_fd, SHUT_WR); /* We must ensure that the read part is still alive when switching to shutw */ @@ -3069,9 +3069,9 @@ int process_cli(struct session *t) } /* read timeout */ else if (tick_is_expired(req->rex, now_ms)) { - buffer_shutr_done(req); + buffer_shutr(req); req->flags |= BF_READ_TIMEOUT; - if (!(rep->flags & BF_SHUTW_STATUS)) { + if (!(rep->flags & BF_SHUTW)) { EV_FD_CLR(t->cli_fd, DIR_RD); trace_term(t, TT_HTTP_CLI_6); } else { @@ -3096,9 +3096,9 @@ int process_cli(struct session *t) } /* write timeout */ else if (tick_is_expired(rep->wex, now_ms)) { - buffer_shutw_done(rep); + buffer_shutw(rep); rep->flags |= BF_WRITE_TIMEOUT; - if (!(req->flags & BF_SHUTR_STATUS)) { + if (!(req->flags & BF_SHUTR)) { EV_FD_CLR(t->cli_fd, DIR_WR); shutdown(t->cli_fd, SHUT_WR); /* We must ensure that the read part is still alive when switching to shutw */ @@ -3128,7 +3128,7 @@ int process_cli(struct session *t) } /* manage read timeout */ - if (!(req->flags & BF_SHUTR_STATUS)) { + if (!(req->flags & BF_SHUTR)) { if (req->l >= req->rlim - req->data) { /* no room to read more data */ if (EV_FD_COND_C(t->cli_fd, DIR_RD)) { @@ -3142,14 +3142,14 @@ int process_cli(struct session *t) } /* manage write timeout */ - if (!(rep->flags & BF_SHUTW_STATUS)) { + if (!(rep->flags & BF_SHUTW)) { /* first, we may have to produce data (eg: stats). * right now, this is limited to the SHUTR state. */ - if (req->flags & BF_SHUTR_STATUS && t->flags & SN_SELF_GEN) { + if (req->flags & BF_SHUTR && t->flags & SN_SELF_GEN) { produce_content(t); if (rep->l == 0) { - buffer_shutw_done(rep); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; trace_term(t, TT_HTTP_CLI_10); @@ -3169,7 +3169,7 @@ int process_cli(struct session *t) if (!tick_isset(rep->wex)) { /* restart writing */ rep->wex = tick_add_ifset(now_ms, t->fe->timeout.client); - if (!(req->flags & BF_SHUTR_STATUS) && tick_isset(rep->wex) && tick_isset(req->rex)) { + if (!(req->flags & BF_SHUTR) && tick_isset(rep->wex) && tick_isset(req->rex)) { /* FIXME: to prevent the client from expiring read timeouts during writes, * we refresh it, except if it was already infinite. */ req->rex = rep->wex; @@ -3225,8 +3225,8 @@ int process_srv(struct session *t) rep->flags |= BF_MAY_FORWARD; if (t->srv_state == SV_STIDLE) { - if ((rep->flags & BF_SHUTW_STATUS) || - ((req->flags & BF_SHUTR_STATUS) && + if ((rep->flags & BF_SHUTW) || + ((req->flags & BF_SHUTR) && (req->l == 0 || t->be->options & PR_O_ABRT_CLOSE))) { /* give up */ req->cex = TICK_ETERNITY; if (t->pend_pos) @@ -3357,8 +3357,8 @@ int process_srv(struct session *t) } } else if (t->srv_state == SV_STCONN) { /* connection in progress */ - if ((rep->flags & BF_SHUTW_STATUS) || - ((req->flags & BF_SHUTR_STATUS) && + if ((rep->flags & BF_SHUTW) || + ((req->flags & BF_SHUTR) && ((req->l == 0 && !(req->flags & BF_WRITE_STATUS)) || t->be->options & PR_O_ABRT_CLOSE))) { /* give up */ req->cex = TICK_ETERNITY; @@ -3508,8 +3508,8 @@ int process_srv(struct session *t) /* read or write error */ /* FIXME: what happens when we have to deal with HTTP ??? */ if (req->flags & BF_WRITE_ERROR || rep->flags & BF_READ_ERROR) { - buffer_shutr_done(rep); - buffer_shutw_done(req); + buffer_shutr(rep); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -3530,10 +3530,10 @@ int process_srv(struct session *t) return 1; } /* last read, or end of client write */ - else if (!(rep->flags & BF_SHUTR_STATUS) && /* not already done */ - rep->flags & (BF_READ_NULL | BF_SHUTW_STATUS)) { - buffer_shutr_done(rep); - if (!(req->flags & BF_SHUTW_STATUS)) { + else if (!(rep->flags & BF_SHUTR) && /* not already done */ + rep->flags & (BF_READ_NULL | BF_SHUTW)) { + buffer_shutr(rep); + if (!(req->flags & BF_SHUTW)) { EV_FD_CLR(t->srv_fd, DIR_RD); trace_term(t, TT_HTTP_SRV_7); } else { @@ -3557,12 +3557,12 @@ int process_srv(struct session *t) * shutdown the outgoing write channel once the response starts * coming from the server. */ - else if (!(req->flags & BF_SHUTW_STATUS) && /* not already done */ + else if (!(req->flags & BF_SHUTW) && /* not already done */ req->l == 0 && req->flags & BF_MAY_FORWARD && - (req->flags & BF_SHUTR_STATUS || + (req->flags & BF_SHUTR || (t->be->options & PR_O_FORCE_CLO && rep->flags & BF_READ_STATUS))) { - buffer_shutw_done(req); - if (!(rep->flags & BF_SHUTR_STATUS)) { + buffer_shutw(req); + if (!(rep->flags & BF_SHUTR)) { EV_FD_CLR(t->srv_fd, DIR_WR); shutdown(t->srv_fd, SHUT_WR); trace_term(t, TT_HTTP_SRV_9); @@ -3586,9 +3586,9 @@ int process_srv(struct session *t) } /* read timeout */ else if (tick_is_expired(rep->rex, now_ms)) { - buffer_shutr_done(rep); + buffer_shutr(rep); rep->flags |= BF_READ_TIMEOUT; - if (!(req->flags & BF_SHUTW_STATUS)) { + if (!(req->flags & BF_SHUTW)) { EV_FD_CLR(t->srv_fd, DIR_RD); trace_term(t, TT_HTTP_SRV_11); } else { @@ -3611,9 +3611,9 @@ int process_srv(struct session *t) } /* write timeout */ else if (tick_is_expired(req->wex, now_ms)) { - buffer_shutw_done(req); + buffer_shutw(req); req->flags |= BF_WRITE_TIMEOUT; - if (!(rep->flags & BF_SHUTR_STATUS)) { + if (!(rep->flags & BF_SHUTR)) { EV_FD_CLR(t->srv_fd, DIR_WR); shutdown(t->srv_fd, SHUT_WR); trace_term(t, TT_HTTP_SRV_13); @@ -3641,7 +3641,7 @@ int process_srv(struct session *t) } /* manage read timeout */ - if (!(rep->flags & BF_SHUTR_STATUS)) { + if (!(rep->flags & BF_SHUTR)) { if (rep->l >= rep->rlim - rep->data) { if (EV_FD_COND_C(t->srv_fd, DIR_RD)) rep->rex = TICK_ETERNITY; @@ -3652,7 +3652,7 @@ int process_srv(struct session *t) } /* manage write timeout */ - if (!(req->flags & BF_SHUTW_STATUS)) { + if (!(req->flags & BF_SHUTW)) { if (req->l == 0 || !(req->flags & BF_MAY_FORWARD)) { /* stop writing */ if (EV_FD_COND_C(t->srv_fd, DIR_WR)) @@ -3663,7 +3663,7 @@ int process_srv(struct session *t) if (!tick_isset(req->wex)) { /* restart writing */ req->wex = tick_add_ifset(now_ms, t->be->timeout.server); - if (!(rep->flags & BF_SHUTR_STATUS) && tick_isset(req->wex) && tick_isset(rep->rex)) { + if (!(rep->flags & BF_SHUTR) && tick_isset(req->wex) && tick_isset(rep->rex)) { /* FIXME: to prevent the server from expiring read timeouts during writes, * we refresh it, except if it was already infinite. */ diff --git a/src/proto_uxst.c b/src/proto_uxst.c index f8026cee2..d74bcb4c9 100644 --- a/src/proto_uxst.c +++ b/src/proto_uxst.c @@ -558,8 +558,8 @@ static int process_uxst_cli(struct session *t) */ /* read or write error */ if (rep->flags & BF_WRITE_ERROR || req->flags & BF_READ_ERROR) { - buffer_shutr_done(req); - buffer_shutw_done(rep); + buffer_shutr(req); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; if (!(t->flags & SN_ERR_MASK)) @@ -584,7 +584,7 @@ static int process_uxst_cli(struct session *t) /* last server read and buffer empty */ else if ((s == SV_STSHUTR || s == SV_STCLOSE) && (rep->l == 0)) { EV_FD_CLR(t->cli_fd, DIR_WR); - buffer_shutw_done(rep); + buffer_shutw(rep); shutdown(t->cli_fd, SHUT_WR); /* We must ensure that the read part is still alive when switching * to shutw */ @@ -614,7 +614,7 @@ static int process_uxst_cli(struct session *t) /* write timeout */ else if (tick_is_expired(rep->wex, now_ms)) { EV_FD_CLR(t->cli_fd, DIR_WR); - buffer_shutw_done(rep); + buffer_shutw(rep); shutdown(t->cli_fd, SHUT_WR); /* We must ensure that the read part is still alive when switching * to shutw */ @@ -679,7 +679,7 @@ static int process_uxst_cli(struct session *t) } else if (c == CL_STSHUTR) { if (rep->flags & BF_WRITE_ERROR) { - buffer_shutw_done(rep); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; if (!(t->flags & SN_ERR_MASK)) @@ -695,13 +695,13 @@ static int process_uxst_cli(struct session *t) return 1; } else if ((s == SV_STSHUTR || s == SV_STCLOSE) && (rep->l == 0)) { - buffer_shutw_done(rep); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; return 1; } else if (tick_is_expired(rep->wex, now_ms)) { - buffer_shutw_done(rep); + buffer_shutw(rep); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; if (!(t->flags & SN_ERR_MASK)) @@ -733,7 +733,7 @@ static int process_uxst_cli(struct session *t) } else if (c == CL_STSHUTW) { if (req->flags & BF_READ_ERROR) { - buffer_shutr_done(req); + buffer_shutr(req); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; if (!(t->flags & SN_ERR_MASK)) @@ -749,13 +749,13 @@ static int process_uxst_cli(struct session *t) return 1; } else if (req->flags & BF_READ_NULL || s == SV_STSHUTW || s == SV_STCLOSE) { - buffer_shutr_done(req); + buffer_shutr(req); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; return 1; } else if (tick_is_expired(req->rex, now_ms)) { - buffer_shutr_done(req); + buffer_shutr(req); fd_delete(t->cli_fd); t->cli_state = CL_STCLOSE; if (!(t->flags & SN_ERR_MASK)) @@ -977,8 +977,8 @@ static int process_uxst_srv(struct session *t) else if (s == SV_STDATA) { /* read or write error */ if (req->flags & BF_WRITE_ERROR || rep->flags & BF_READ_ERROR) { - buffer_shutr_done(rep); - buffer_shutw_done(req); + buffer_shutr(rep); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -1009,7 +1009,7 @@ static int process_uxst_srv(struct session *t) /* end of client read and no more data to send */ else if ((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) { EV_FD_CLR(t->srv_fd, DIR_WR); - buffer_shutw_done(req); + buffer_shutw(req); shutdown(t->srv_fd, SHUT_WR); /* We must ensure that the read part is still alive when switching * to shutw */ @@ -1033,7 +1033,7 @@ static int process_uxst_srv(struct session *t) /* write timeout */ else if (tv_isle(&req->wex, &now)) { EV_FD_CLR(t->srv_fd, DIR_WR); - buffer_shutw_done(req); + buffer_shutw(req); shutdown(t->srv_fd, SHUT_WR); /* We must ensure that the read part is still alive when switching * to shutw */ @@ -1085,7 +1085,7 @@ static int process_uxst_srv(struct session *t) else if (s == SV_STSHUTR) { if (req->flags & BF_WRITE_ERROR) { //EV_FD_CLR(t->srv_fd, DIR_WR); - buffer_shutw_done(req); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -1108,7 +1108,7 @@ static int process_uxst_srv(struct session *t) } else if ((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) { //EV_FD_CLR(t->srv_fd, DIR_WR); - buffer_shutw_done(req); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) t->srv->cur_sess--; @@ -1124,7 +1124,7 @@ static int process_uxst_srv(struct session *t) } else if (tv_isle(&req->wex, &now)) { //EV_FD_CLR(t->srv_fd, DIR_WR); - buffer_shutw_done(req); + buffer_shutw(req); fd_delete(t->srv_fd); if (t->srv) t->srv->cur_sess--; @@ -1160,7 +1160,7 @@ static int process_uxst_srv(struct session *t) else if (s == SV_STSHUTW) { if (rep->flags & BF_READ_ERROR) { //EV_FD_CLR(t->srv_fd, DIR_RD); - buffer_shutr_done(rep); + buffer_shutr(rep); fd_delete(t->srv_fd); if (t->srv) { t->srv->cur_sess--; @@ -1183,7 +1183,7 @@ static int process_uxst_srv(struct session *t) } else if (rep->flags & BF_READ_NULL || c == CL_STSHUTW || c == CL_STCLOSE) { //EV_FD_CLR(t->srv_fd, DIR_RD); - buffer_shutr_done(rep); + buffer_shutr(rep); fd_delete(t->srv_fd); if (t->srv) t->srv->cur_sess--; @@ -1199,7 +1199,7 @@ static int process_uxst_srv(struct session *t) } else if (tv_isle(&rep->rex, &now)) { //EV_FD_CLR(t->srv_fd, DIR_RD); - buffer_shutr_done(rep); + buffer_shutr(rep); fd_delete(t->srv_fd); if (t->srv) t->srv->cur_sess--; diff --git a/src/stream_sock.c b/src/stream_sock.c index da2004d45..3e3e0b9d8 100644 --- a/src/stream_sock.c +++ b/src/stream_sock.c @@ -380,7 +380,7 @@ int stream_sock_write(int fd) { * we refresh it. A solution would be to merge read+write timeouts into a * unique one, although that needs some study particularly on full-duplex * TCP connections. */ - if (tick_isset(b->rex) && !(b->flags & BF_SHUTR_STATUS)) + if (tick_isset(b->rex) && !(b->flags & BF_SHUTR)) b->rex = b->wex; } }