blob: 74fe0b296fa6724e7516385aff00ae79d8f9b4e9 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Functions operating on SOCK_STREAM and buffers.
3 *
Willy Tarreaub22e55b2011-03-20 10:16:46 +01004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau6b4aad42009-01-18 21:59:13 +010013#define _GNU_SOURCE
Willy Tarreaubaaee002006-06-26 02:48:02 +020014#include <errno.h>
15#include <fcntl.h>
16#include <stdio.h>
17#include <stdlib.h>
18
19#include <sys/socket.h>
20#include <sys/stat.h>
21#include <sys/types.h>
22
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040023#include <netinet/tcp.h>
24
Willy Tarreau2dd0d472006-06-29 17:53:05 +020025#include <common/compat.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020026#include <common/config.h>
Willy Tarreaud6f087e2008-01-18 17:20:13 +010027#include <common/debug.h>
Willy Tarreau83749182007-04-15 20:56:27 +020028#include <common/standard.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020029#include <common/ticks.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020030#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020031
Willy Tarreau2d212792008-08-27 21:41:35 +020032#include <proto/buffers.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020033#include <proto/fd.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020034#include <proto/freq_ctr.h>
Willy Tarreaub22e55b2011-03-20 10:16:46 +010035#include <proto/frontend.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020036#include <proto/log.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010037#include <proto/pipe.h>
Willy Tarreaufe598a72010-09-21 21:48:23 +020038#include <proto/protocols.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020039#include <proto/stream_sock.h>
40#include <proto/task.h>
41
Willy Tarreau5bd8c372009-01-19 00:32:22 +010042#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020043
Willy Tarreau6b4aad42009-01-18 21:59:13 +010044#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau43d8fb22011-08-22 17:12:02 +020045#include <common/splice.h>
Willy Tarreau5bd8c372009-01-19 00:32:22 +010046
47/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
48 * because of timestamps. Use this as a hint for not looping on splice().
49 */
50#define SPLICE_FULL_HINT 16*1448
51
Willy Tarreaua9de3332009-11-28 07:47:10 +010052/* how many data we attempt to splice at once when the buffer is configured for
53 * infinite forwarding */
54#define MAX_SPLICE_AT_ONCE (1<<30)
55
Willy Tarreau5bd8c372009-01-19 00:32:22 +010056/* Returns :
57 * -1 if splice is not possible or not possible anymore and we must switch to
58 * user-land copy (eg: to_forward reached)
59 * 0 when we know that polling is required to get more data (EAGAIN)
60 * 1 for all other cases (we can safely try again, or if an activity has been
61 * detected (DATA/NULL/ERR))
62 * Sets :
63 * BF_READ_NULL
64 * BF_READ_PARTIAL
65 * BF_WRITE_PARTIAL (during copy)
Willy Tarreauba0b63d2009-09-20 08:09:44 +020066 * BF_OUT_EMPTY (during copy)
Willy Tarreau5bd8c372009-01-19 00:32:22 +010067 * SI_FL_ERR
68 * SI_FL_WAIT_ROOM
69 * (SI_FL_WAIT_RECV)
Willy Tarreau3eba98a2009-01-25 13:56:13 +010070 *
71 * This function automatically allocates a pipe from the pipe pool. It also
72 * carefully ensures to clear b->pipe whenever it leaves the pipe empty.
Willy Tarreau5bd8c372009-01-19 00:32:22 +010073 */
74static int stream_sock_splice_in(struct buffer *b, struct stream_interface *si)
75{
Willy Tarreau82a04562011-12-11 22:37:06 +010076 static int splice_detects_close;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010077 int fd = si->fd;
Willy Tarreau31971e52009-09-20 12:07:52 +020078 int ret;
79 unsigned long max;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010080 int retval = 1;
81
82 if (!b->to_forward)
83 return -1;
84
85 if (!(b->flags & BF_KERN_SPLICING))
86 return -1;
87
Willy Tarreau02d6cfc2012-03-01 18:19:58 +010088 if (buffer_not_empty(b)) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +010089 /* We're embarrassed, there are already data pending in
90 * the buffer and we don't want to have them at two
91 * locations at a time. Let's indicate we need some
92 * place and ask the consumer to hurry.
93 */
94 si->flags |= SI_FL_WAIT_ROOM;
95 EV_FD_CLR(fd, DIR_RD);
96 b->rex = TICK_ETERNITY;
97 b->cons->chk_snd(b->cons);
98 return 1;
99 }
100
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100101 if (unlikely(b->pipe == NULL)) {
102 if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100103 b->flags &= ~BF_KERN_SPLICING;
104 return -1;
105 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100106 }
107
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100108 /* At this point, b->pipe is valid */
109
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100110 while (1) {
Willy Tarreaua9de3332009-11-28 07:47:10 +0100111 if (b->to_forward == BUF_INFINITE_FORWARD)
112 max = MAX_SPLICE_AT_ONCE;
113 else
114 max = b->to_forward;
115
Willy Tarreau31971e52009-09-20 12:07:52 +0200116 if (!max) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100117 /* It looks like the buffer + the pipe already contain
118 * the maximum amount of data to be transferred. Try to
119 * send those data immediately on the other side if it
120 * is currently waiting.
121 */
122 retval = -1; /* end of forwarding */
123 break;
124 }
125
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100126 ret = splice(fd, NULL, b->pipe->prod, NULL, max,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100127 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
128
129 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100130 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100131 /* connection closed. This is only detected by
Willy Tarreau82a04562011-12-11 22:37:06 +0100132 * recent kernels (>= 2.6.27.13). If we notice
133 * it works, we store the info for later use.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100134 */
Willy Tarreau82a04562011-12-11 22:37:06 +0100135 splice_detects_close = 1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100136 b->flags |= BF_READ_NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100137 retval = 1; /* no need for further polling */
138 break;
139 }
140
141 if (errno == EAGAIN) {
142 /* there are two reasons for EAGAIN :
143 * - nothing in the socket buffer (standard)
144 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100145 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100146 * Since we don't know if pipe is full, we'll
147 * stop if the pipe is not empty. Anyway, we
148 * will almost always fill/empty the pipe.
149 */
150
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100151 if (b->pipe->data) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100152 si->flags |= SI_FL_WAIT_ROOM;
153 retval = 1;
154 break;
155 }
156
Willy Tarreau82a04562011-12-11 22:37:06 +0100157 /* We don't know if the connection was closed,
158 * but if we know splice detects close, then we
159 * know it for sure.
Willy Tarreau98b306b2009-01-25 11:11:32 +0100160 * But if we're called upon POLLIN with an empty
Willy Tarreau82a04562011-12-11 22:37:06 +0100161 * pipe and get EAGAIN, it is suspect enough to
Willy Tarreau98b306b2009-01-25 11:11:32 +0100162 * try to fall back to the normal recv scheme
163 * which will be able to deal with the situation.
164 */
Willy Tarreau82a04562011-12-11 22:37:06 +0100165 if (splice_detects_close)
166 retval = 0; /* we know for sure that it's EAGAIN */
167 else
168 retval = -1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100169 break;
170 }
Willy Tarreaudc340a92009-06-28 23:10:19 +0200171
Willy Tarreaua9de3332009-11-28 07:47:10 +0100172 if (errno == ENOSYS || errno == EINVAL) {
Willy Tarreaudc340a92009-06-28 23:10:19 +0200173 /* splice not supported on this end, disable it */
174 b->flags &= ~BF_KERN_SPLICING;
175 si->flags &= ~SI_FL_CAP_SPLICE;
176 put_pipe(b->pipe);
177 b->pipe = NULL;
178 return -1;
179 }
180
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100181 /* here we have another error */
182 si->flags |= SI_FL_ERR;
183 retval = 1;
184 break;
185 } /* ret <= 0 */
186
Willy Tarreau31971e52009-09-20 12:07:52 +0200187 if (b->to_forward != BUF_INFINITE_FORWARD)
188 b->to_forward -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100189 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100190 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100191 b->flags |= BF_READ_PARTIAL;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200192 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100193
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100194 if (b->pipe->data >= SPLICE_FULL_HINT ||
195 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100196 /* We've read enough of it for this time. */
197 retval = 1;
198 break;
199 }
200 } /* while */
201
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100202 if (unlikely(!b->pipe->data)) {
203 put_pipe(b->pipe);
204 b->pipe = NULL;
205 }
206
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100207 return retval;
208}
209
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100210#endif /* CONFIG_HAP_LINUX_SPLICE */
211
212
Willy Tarreaubaaee002006-06-26 02:48:02 +0200213/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200214 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200215 * It returns 0 if we have a high confidence that we will not be
216 * able to read more data without polling first. Returns non-zero
217 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200218 */
Willy Tarreaud7971282006-07-29 18:36:34 +0200219int stream_sock_read(int fd) {
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200220 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200221 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200222 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100223 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200224
225#ifdef DEBUG_FULL
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100226 fprintf(stderr,"stream_sock_read : fd=%d, ev=0x%02x, owner=%p\n", fd, fdtab[fd].ev, fdtab[fd].owner);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200227#endif
228
Willy Tarreau83749182007-04-15 20:56:27 +0200229 retval = 1;
230
Willy Tarreau71543652009-07-14 19:55:05 +0200231 /* stop immediately on errors. Note that we DON'T want to stop on
232 * POLL_ERR, as the poller might report a write error while there
233 * are still data available in the recv buffer. This typically
234 * happens when we send too large a request to a backend server
235 * which rejects it before reading it all.
236 */
237 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200238 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100239
240 /* stop here if we reached the end of data */
241 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
242 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200243
Willy Tarreaud06e7112009-03-29 10:18:41 +0200244 /* maybe we were called immediately after an asynchronous shutr */
245 if (b->flags & BF_SHUTR)
246 goto out_wakeup;
247
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100248#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau14acc702011-05-11 20:47:24 +0200249 if (b->to_forward >= MIN_SPLICE_FORWARD && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100250
251 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
252 * Since older splice() implementations were buggy and returned
253 * EAGAIN on end of read, let's bypass the call to splice() now.
254 */
255 if (fdtab[fd].ev & FD_POLL_HUP)
256 goto out_shutdown_r;
257
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100258 retval = stream_sock_splice_in(b, si);
259
260 if (retval >= 0) {
261 if (si->flags & SI_FL_ERR)
262 goto out_error;
263 if (b->flags & BF_READ_NULL)
264 goto out_shutdown_r;
265 goto out_wakeup;
266 }
267 /* splice not possible (anymore), let's go on on standard copy */
268 }
269#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200270 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200271 while (1) {
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100272 max = buffer_max_len(b) - buffer_len(b);
Willy Tarreau864e8252009-12-28 17:36:37 +0100273
274 if (max <= 0) {
275 b->flags |= BF_FULL;
276 si->flags |= SI_FL_WAIT_ROOM;
277 break;
278 }
279
Willy Tarreau6996e152007-04-30 14:37:43 +0200280 /*
281 * 1. compute the maximum block size we can read at once.
282 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100283 if (buffer_empty(b)) {
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100284 /* let's realign the buffer to optimize I/O */
285 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200286 }
287 else if (b->r > b->w) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100288 /* remaining space wraps at the end, with a moving limit */
289 if (max > b->data + b->size - b->r)
290 max = b->data + b->size - b->r;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100291 }
Willy Tarreau864e8252009-12-28 17:36:37 +0100292 /* else max is already OK */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200293
Willy Tarreau6996e152007-04-30 14:37:43 +0200294 /*
295 * 2. read the largest possible block
296 */
Willy Tarreaufc1daaf2010-01-15 10:26:13 +0100297 ret = recv(fd, b->r, max, 0);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200298
Willy Tarreau83749182007-04-15 20:56:27 +0200299 if (ret > 0) {
300 b->r += ret;
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100301 b->i += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200302 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100303
Willy Tarreau2e046c62012-03-01 16:08:30 +0100304 /* if we're allowed to directly forward data, we must update ->o */
Willy Tarreau31971e52009-09-20 12:07:52 +0200305 if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
306 unsigned long fwd = ret;
307 if (b->to_forward != BUF_INFINITE_FORWARD) {
308 if (fwd > b->to_forward)
309 fwd = b->to_forward;
310 b->to_forward -= fwd;
311 }
Willy Tarreau2e046c62012-03-01 16:08:30 +0100312 b->o += fwd;
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100313 b->i -= fwd;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200314 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100315 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100316
Willy Tarreaub38903c2008-11-23 21:33:29 +0100317 if (fdtab[fd].state == FD_STCONN)
318 fdtab[fd].state = FD_STREADY;
319
Willy Tarreau3da77c52008-08-29 09:58:42 +0200320 b->flags |= BF_READ_PARTIAL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100321
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200322 if (b->r == b->data + b->size) {
Willy Tarreau83749182007-04-15 20:56:27 +0200323 b->r = b->data; /* wrap around the buffer */
324 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100325
Willy Tarreau83749182007-04-15 20:56:27 +0200326 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100327
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100328 if (buffer_len(b) >= buffer_max_len(b)) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200329 /* The buffer is now full, there's no point in going through
330 * the loop again.
331 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100332 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == buffer_len(b))) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200333 b->xfer_small = 0;
334 b->xfer_large++;
335 if (b->xfer_large >= 3) {
336 /* we call this buffer a fast streamer if it manages
337 * to be filled in one call 3 consecutive times.
338 */
339 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
340 //fputc('+', stderr);
341 }
342 }
343 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200344 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200345 b->xfer_large = 0;
346 b->xfer_small++;
347 if (b->xfer_small >= 2) {
348 /* if the buffer has been at least half full twice,
349 * we receive faster than we send, so at least it
350 * is not a "fast streamer".
351 */
352 b->flags &= ~BF_STREAMER_FAST;
353 //fputc('-', stderr);
354 }
355 }
356 else {
357 b->xfer_small = 0;
358 b->xfer_large = 0;
359 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100360
361 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100362 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100363 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200364 }
365
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200366 /* if too many bytes were missing from last read, it means that
367 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100368 * not have them in buffers. BTW, if FD_POLL_HUP was present,
369 * it means that we have reached the end and that the connection
370 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200371 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100372 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200373 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200374 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200375 b->xfer_large = 0;
376 b->xfer_small++;
377 if (b->xfer_small >= 3) {
378 /* we have read less than half of the buffer in
379 * one pass, and this happened at least 3 times.
380 * This is definitely not a streamer.
381 */
382 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
383 //fputc('!', stderr);
384 }
385 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200386 /* unfortunately, on level-triggered events, POLL_HUP
387 * is generally delivered AFTER the system buffer is
388 * empty, so this one might never match.
389 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100390 if (fdtab[fd].ev & FD_POLL_HUP)
391 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200392
393 /* if a streamer has read few data, it may be because we
394 * have exhausted system buffers. It's not worth trying
395 * again.
396 */
397 if (b->flags & BF_STREAMER)
398 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200399
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100400 /* generally if we read something smaller than 1 or 2 MSS,
401 * it means that either we have exhausted the system's
402 * buffers (streamer or question-response protocol) or
403 * that the connection will be closed. Streamers are
404 * easily detected so we return early. For other cases,
405 * it's still better to perform a last read to be sure,
406 * because it may save one complete poll/read/wakeup cycle
407 * in case of shutdown.
408 */
409 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
410 break;
411
412 /* if we read a large block smaller than what we requested,
413 * it's almost certain we'll never get anything more.
414 */
415 if (ret >= global.tune.recv_enough)
416 break;
417 }
Willy Tarreau83749182007-04-15 20:56:27 +0200418
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100419 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200420 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200421 }
422 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200423 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100424 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200425 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200426 else if (errno == EAGAIN) {
427 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100428 * nothing to read left if we did not read much, ie
429 * less than what we were still expecting to read.
430 * But we may have done some work justifying to notify
431 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200432 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100433 if (cur_read < MIN_RET_FOR_READ_LOOP)
434 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200435 break;
436 }
437 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200438 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200439 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200440 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200441
Willy Tarreau6996e152007-04-30 14:37:43 +0200442 out_wakeup:
Willy Tarreau22be90b2011-05-11 20:32:36 +0200443 /* We might have some data the consumer is waiting for.
444 * We can do fast-forwarding, but we avoid doing this for partial
445 * buffers, because it is very likely that it will be done again
446 * immediately afterwards once the following data is parsed (eg:
447 * HTTP chunking).
448 */
Willy Tarreaueb9fd512011-12-11 22:11:47 +0100449 if (b->pipe || /* always try to send spliced data */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100450 (b->i == 0 && (b->cons->flags & SI_FL_WAIT_DATA))) {
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100451 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100452
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100453 b->cons->chk_snd(b->cons);
454
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100455 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100456 if (!(b->flags & BF_FULL) &&
457 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100458 si->flags &= ~SI_FL_WAIT_ROOM;
459 }
460
461 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100462 EV_FD_CLR(fd, DIR_RD);
463 b->rex = TICK_ETERNITY;
464 }
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200465 else if ((b->flags & (BF_SHUTR|BF_READ_PARTIAL|BF_FULL|BF_DONT_READ|BF_READ_NOEXP)) == BF_READ_PARTIAL)
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100466 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100467
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100468 /* we have to wake up if there is a special event or if we don't have
469 * any more data to forward.
470 */
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200471 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100472 si->state != SI_ST_EST ||
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200473 (si->flags & SI_FL_ERR) ||
474 ((b->flags & BF_READ_PARTIAL) && (!b->to_forward || b->cons->state != SI_ST_EST)))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100475 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200476
477 if (b->flags & BF_READ_ACTIVITY)
478 b->flags &= ~BF_READ_DONTWAIT;
479
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100480 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200481 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200482
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100483 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200484 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100485 fdtab[fd].ev &= ~FD_POLL_HUP;
486 b->flags |= BF_READ_NULL;
Willy Tarreau520d95e2009-09-19 21:04:57 +0200487 if (b->flags & BF_AUTO_CLOSE)
Willy Tarreau418fd472009-09-06 21:37:23 +0200488 buffer_shutw_now(b);
Willy Tarreau99126c32008-11-27 10:30:51 +0100489 stream_sock_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200490 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100491
Willy Tarreau6996e152007-04-30 14:37:43 +0200492 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100493 /* Read error on the file descriptor. We mark the FD as STERROR so
494 * that we don't use it anymore. The error is reported to the stream
495 * interface which will take proper action. We must not perturbate the
496 * buffer because the stream interface wants to ensure transparent
497 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200498 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100499
Willy Tarreau6996e152007-04-30 14:37:43 +0200500 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100501 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100502 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100503 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100504 retval = 1;
505 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200506}
507
508
509/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100510 * This function is called to send buffer data to a stream socket.
511 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100512 * before calling it again, otherwise 1. If a pipe was associated with the
513 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200514 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100515static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100516{
Willy Tarreau83749182007-04-15 20:56:27 +0200517 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100518 int retval = 1;
519 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200520
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100521 if (unlikely(si->send_proxy_ofs)) {
522 /* The target server expects a PROXY line to be sent first.
523 * If the send_proxy_ofs is negative, it corresponds to the
524 * offset to start sending from then end of the proxy string
525 * (which is recomputed every time since it's constant). If
526 * it is positive, it means we have to send from the start.
527 */
528 ret = make_proxy_line(trash, sizeof(trash),
Willy Tarreau6471afb2011-09-23 10:54:59 +0200529 &b->prod->addr.from, &b->prod->addr.to);
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100530 if (!ret)
531 return -1;
532
533 if (si->send_proxy_ofs > 0)
534 si->send_proxy_ofs = -ret; /* first call */
535
536 /* we have to send trash from (ret+sp for -sp bytes) */
537 ret = send(si->fd, trash + ret + si->send_proxy_ofs, -si->send_proxy_ofs,
538 (b->flags & BF_OUT_EMPTY) ? 0 : MSG_MORE);
539 if (ret > 0) {
540 if (fdtab[si->fd].state == FD_STCONN)
541 fdtab[si->fd].state = FD_STREADY;
542
543 si->send_proxy_ofs += ret; /* becomes zero once complete */
544 b->flags |= BF_WRITE_NULL; /* connect() succeeded */
545 }
546 else if (ret == 0 || errno == EAGAIN) {
547 /* nothing written, we need to poll for write first */
548 return 0;
549 }
550 else {
551 /* bad, we got an error */
552 return -1;
553 }
554 }
555
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100556#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100557 while (b->pipe) {
558 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100559 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
560 if (ret <= 0) {
561 if (ret == 0 || errno == EAGAIN) {
562 retval = 0;
563 return retval;
564 }
565 /* here we have another error */
566 retval = -1;
567 return retval;
568 }
569
570 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100571 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100572
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100573 if (!b->pipe->data) {
574 put_pipe(b->pipe);
575 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100576 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100577 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100578
579 if (--write_poll <= 0)
580 return retval;
Willy Tarreaueb9fd512011-12-11 22:11:47 +0100581
582 /* The only reason we did not empty the pipe is that the output
583 * buffer is full.
584 */
585 return 0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100586 }
587
588 /* At this point, the pipe is empty, but we may still have data pending
589 * in the normal buffer.
590 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100591#endif
Willy Tarreau2e046c62012-03-01 16:08:30 +0100592 if (!b->o) {
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200593 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100594 return retval;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200595 }
Willy Tarreau83749182007-04-15 20:56:27 +0200596
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100597 /* when we're in this loop, we already know that there is no spliced
598 * data left, and that there are sendable buffered data.
599 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200600 while (1) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100601 if (b->r > b->w)
Willy Tarreau83749182007-04-15 20:56:27 +0200602 max = b->r - b->w;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100603 else
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200604 max = b->data + b->size - b->w;
Willy Tarreau83749182007-04-15 20:56:27 +0200605
Willy Tarreauf890dc92008-12-13 21:12:26 +0100606 /* limit the amount of outgoing data if required */
Willy Tarreau2e046c62012-03-01 16:08:30 +0100607 if (max > b->o)
608 max = b->o;
Willy Tarreauf890dc92008-12-13 21:12:26 +0100609
Willy Tarreau6db06d32009-08-19 11:14:11 +0200610 /* check if we want to inform the kernel that we're interested in
611 * sending more data after this call. We want this if :
612 * - we're about to close after this last send and want to merge
613 * the ongoing FIN with the last segment.
614 * - we know we can't send everything at once and must get back
615 * here because of unaligned data
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100616 * - there is still a finite amount of data to forward
Willy Tarreau6db06d32009-08-19 11:14:11 +0200617 * The test is arranged so that the most common case does only 2
618 * tests.
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200619 */
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200620
Willy Tarreauface8392010-01-03 11:37:54 +0100621 if (MSG_NOSIGNAL && MSG_MORE) {
Willy Tarreau6db06d32009-08-19 11:14:11 +0200622 unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
623
Willy Tarreau96e31212011-05-30 18:10:30 +0200624 if ((!(b->flags & BF_NEVER_WAIT) &&
625 ((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
626 (b->flags & BF_EXPECT_MORE))) ||
Willy Tarreau2e046c62012-03-01 16:08:30 +0100627 ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->o)) ||
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100628 (max != b->o)) {
Willy Tarreauface8392010-01-03 11:37:54 +0100629 send_flag |= MSG_MORE;
630 }
Willy Tarreau6db06d32009-08-19 11:14:11 +0200631
Willy Tarreau2be39392010-01-03 17:24:51 +0100632 /* this flag has precedence over the rest */
633 if (b->flags & BF_SEND_DONTWAIT)
634 send_flag &= ~MSG_MORE;
635
Willy Tarreau6db06d32009-08-19 11:14:11 +0200636 ret = send(si->fd, b->w, max, send_flag);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200637 } else {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200638 int skerr;
639 socklen_t lskerr = sizeof(skerr);
640
Willy Tarreau87bed622009-03-08 22:25:28 +0100641 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200642 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200643 ret = -1;
644 else
Willy Tarreau87bed622009-03-08 22:25:28 +0100645 ret = send(si->fd, b->w, max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200646 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200647
648 if (ret > 0) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100649 if (fdtab[si->fd].state == FD_STCONN)
650 fdtab[si->fd].state = FD_STREADY;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100651
Willy Tarreau3da77c52008-08-29 09:58:42 +0200652 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200653
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100654 b->w += ret;
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200655 if (b->w == b->data + b->size)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100656 b->w = b->data; /* wrap around the buffer */
657
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100658 b->o -= ret;
659 if (likely(!buffer_len(b)))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100660 /* optimize data alignment in the buffer */
661 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200662
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100663 if (likely(buffer_len(b) < buffer_max_len(b)))
664 b->flags &= ~BF_FULL;
665
Willy Tarreau2e046c62012-03-01 16:08:30 +0100666 if (!b->o) {
Willy Tarreauf17810e2012-03-09 18:10:44 +0100667 /* Always clear both flags once everything has been sent, they're one-shot */
668 b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT);
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200669 if (likely(!b->pipe))
670 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100671 break;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200672 }
Willy Tarreau83749182007-04-15 20:56:27 +0200673
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200674 /* if the system buffer is full, don't insist */
675 if (ret < max)
676 break;
677
Willy Tarreau6996e152007-04-30 14:37:43 +0200678 if (--write_poll <= 0)
679 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200680 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200681 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100682 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200683 retval = 0;
684 break;
685 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200686 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100687 /* bad, we got an error */
688 retval = -1;
689 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200690 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200691 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200692
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100693 return retval;
694}
Willy Tarreau6996e152007-04-30 14:37:43 +0200695
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100696
697/*
698 * This function is called on a write event from a stream socket.
699 * It returns 0 if the caller needs to poll before calling it again, otherwise
700 * non-zero.
701 */
702int stream_sock_write(int fd)
703{
704 struct stream_interface *si = fdtab[fd].owner;
705 struct buffer *b = si->ob;
706 int retval = 1;
707
708#ifdef DEBUG_FULL
709 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
710#endif
711
712 retval = 1;
Willy Tarreau71543652009-07-14 19:55:05 +0200713 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100714 goto out_error;
715
Willy Tarreaud06e7112009-03-29 10:18:41 +0200716 /* we might have been called just after an asynchronous shutw */
717 if (b->flags & BF_SHUTW)
718 goto out_wakeup;
719
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100720 if (likely(!(b->flags & BF_OUT_EMPTY) || si->send_proxy_ofs)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100721 /* OK there are data waiting to be sent */
722 retval = stream_sock_write_loop(si, b);
723 if (retval < 0)
724 goto out_error;
Willy Tarreau68f49da2011-03-28 23:17:54 +0200725 else if (retval == 0 && si->send_proxy_ofs)
726 goto out_may_wakeup; /* we failed to send the PROXY string */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200727 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100728 else {
729 /* may be we have received a connection acknowledgement in TCP mode without data */
730 if (likely(fdtab[fd].state == FD_STCONN)) {
731 /* We have no data to send to check the connection, and
732 * getsockopt() will not inform us whether the connection
733 * is still pending. So we'll reuse connect() to check the
734 * state of the socket. This has the advantage of givig us
735 * the following info :
736 * - error
737 * - connecting (EALREADY, EINPROGRESS)
738 * - connected (EISCONN, 0)
739 */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +0200740 if ((connect(fd, fdinfo[fd].peeraddr, fdinfo[fd].peerlen) == 0))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100741 errno = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200742
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100743 if (errno == EALREADY || errno == EINPROGRESS) {
744 retval = 0;
745 goto out_may_wakeup;
746 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100747
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100748 if (errno && errno != EISCONN)
749 goto out_error;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200750
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100751 /* OK we just need to indicate that we got a connection
752 * and that we wrote nothing.
753 */
754 b->flags |= BF_WRITE_NULL;
755 fdtab[fd].state = FD_STREADY;
756 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200757
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100758 /* Funny, we were called to write something but there wasn't
759 * anything. We can get there, for example if we were woken up
Willy Tarreau2e046c62012-03-01 16:08:30 +0100760 * on a write event to finish the splice, but the ->o is 0
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100761 * so we cannot write anything from the buffer. Let's disable
762 * the write event and pretend we never came there.
763 */
764 }
765
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200766 if (b->flags & BF_OUT_EMPTY) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100767 /* the connection is established but we can't write. Either the
768 * buffer is empty, or we just refrain from sending because the
Willy Tarreau2e046c62012-03-01 16:08:30 +0100769 * ->o limit was reached. Maybe we just wrote the last
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100770 * chunk and need to close.
771 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200772 if (((b->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100773 (si->state == SI_ST_EST)) {
774 stream_sock_shutw(si);
775 goto out_wakeup;
776 }
777
Willy Tarreau59454bf2009-09-20 11:13:40 +0200778 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreauac128fe2009-01-09 13:05:19 +0100779 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100780
Willy Tarreauac128fe2009-01-09 13:05:19 +0100781 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100782 b->wex = TICK_ETERNITY;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100783 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100784
785 out_may_wakeup:
786 if (b->flags & BF_WRITE_ACTIVITY) {
787 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200788 if ((b->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100789 b->wex = tick_add_ifset(now_ms, b->wto);
790
791 out_wakeup:
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200792 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100793 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200794 * during writes, we refresh it. We only do this if the
795 * interface is not configured for "independant streams",
796 * because for some applications it's better not to do this,
797 * for instance when continuously exchanging small amounts
798 * of data which can full the socket buffers long before a
799 * write timeout is detected.
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100800 */
801 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
802 }
803
804 /* the producer might be waiting for more room to store data */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200805 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100806 (b->prod->flags & SI_FL_WAIT_ROOM)))
807 b->prod->chk_rcv(b->prod);
808
809 /* we have to wake up if there is a special event or if we don't have
810 * any more data to forward and it's not planned to send any more.
811 */
812 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200813 ((b->flags & BF_OUT_EMPTY) && !b->to_forward) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100814 si->state != SI_ST_EST ||
815 b->prod->state != SI_ST_EST))
816 task_wakeup(si->owner, TASK_WOKEN_IO);
817 }
818
819 fdtab[fd].ev &= ~FD_POLL_OUT;
820 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100821
Willy Tarreau6996e152007-04-30 14:37:43 +0200822 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100823 /* Write error on the file descriptor. We mark the FD as STERROR so
824 * that we don't use it anymore. The error is reported to the stream
825 * interface which will take proper action. We must not perturbate the
826 * buffer because the stream interface wants to ensure transparent
827 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200828 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100829
Willy Tarreau6996e152007-04-30 14:37:43 +0200830 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100831 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100832 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100833 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200834 task_wakeup(si->owner, TASK_WOKEN_IO);
835 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200836}
837
Willy Tarreau48adac52008-08-30 04:58:38 +0200838/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200839 * This function performs a shutdown-write on a stream interface in a connected or
840 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100841 * or closes the file descriptor and marks itself as closed. The buffer flags are
Willy Tarreau7340ca52010-01-16 10:03:45 +0100842 * updated to reflect the new state. It does also close everything is the SI was
843 * marked as being in error state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200844 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100845void stream_sock_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200846{
Willy Tarreau418fd472009-09-06 21:37:23 +0200847 si->ob->flags &= ~BF_SHUTW_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100848 if (si->ob->flags & BF_SHUTW)
849 return;
850 si->ob->flags |= BF_SHUTW;
851 si->ob->wex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100852 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau99126c32008-11-27 10:30:51 +0100853
Willy Tarreaub38903c2008-11-23 21:33:29 +0100854 switch (si->state) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100855 case SI_ST_EST:
Willy Tarreau720058c2009-07-14 19:21:50 +0200856 /* we have to shut before closing, otherwise some short messages
857 * may never leave the system, especially when there are remaining
858 * unread data in the socket input buffer, or when nolinger is set.
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100859 * However, if SI_FL_NOLINGER is explicitly set, we know there is
860 * no risk so we close both sides immediately.
Willy Tarreau720058c2009-07-14 19:21:50 +0200861 */
Willy Tarreau7340ca52010-01-16 10:03:45 +0100862 if (si->flags & SI_FL_ERR) {
863 /* quick close, the socket is already shut. Remove pending flags. */
864 si->flags &= ~SI_FL_NOLINGER;
865 } else if (si->flags & SI_FL_NOLINGER) {
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100866 si->flags &= ~SI_FL_NOLINGER;
867 setsockopt(si->fd, SOL_SOCKET, SO_LINGER,
868 (struct linger *) &nolinger, sizeof(struct linger));
869 } else {
870 EV_FD_CLR(si->fd, DIR_WR);
871 shutdown(si->fd, SHUT_WR);
Willy Tarreau720058c2009-07-14 19:21:50 +0200872
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100873 if (!(si->ib->flags & (BF_SHUTR|BF_DONT_READ)))
874 return;
875 }
Willy Tarreau5d707e12009-06-28 11:09:07 +0200876
Willy Tarreaub38903c2008-11-23 21:33:29 +0100877 /* fall through */
878 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100879 /* we may have to close a pending connection, and mark the
880 * response buffer as shutr
881 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200882 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100883 /* fall through */
884 case SI_ST_CER:
Willy Tarreau32d3ee92010-12-29 14:03:02 +0100885 case SI_ST_QUE:
886 case SI_ST_TAR:
Willy Tarreau7f006512008-12-07 14:04:04 +0100887 si->state = SI_ST_DIS;
Willy Tarreauad4cd582012-03-10 13:42:32 +0100888
889 if (si->release)
890 si->release(si);
Willy Tarreau7f006512008-12-07 14:04:04 +0100891 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200892 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100893 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100894 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100895 si->exp = TICK_ETERNITY;
Willy Tarreau48adac52008-08-30 04:58:38 +0200896 }
Willy Tarreau48adac52008-08-30 04:58:38 +0200897}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200898
Willy Tarreau2d212792008-08-27 21:41:35 +0200899/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200900 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100901 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100902 * or closes the file descriptor and marks itself as closed. The buffer flags are
903 * updated to reflect the new state.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200904 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100905void stream_sock_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200906{
Willy Tarreau418fd472009-09-06 21:37:23 +0200907 si->ib->flags &= ~BF_SHUTR_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100908 if (si->ib->flags & BF_SHUTR)
909 return;
910 si->ib->flags |= BF_SHUTR;
911 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100912 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100913
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100914 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100915 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200916
Willy Tarreaucff64112008-11-03 06:26:53 +0100917 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200918 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100919 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100920 si->exp = TICK_ETERNITY;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200921
922 if (si->release)
923 si->release(si);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100924 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200925 }
926 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100927 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200928}
929
930/*
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200931 * Updates a connected stream_sock file descriptor status and timeouts
932 * according to the buffers' flags. It should only be called once after the
933 * buffer flags have settled down, and before they are cleared. It doesn't
934 * harm to call it as often as desired (it just slightly hurts performance).
935 */
Willy Tarreaub0253252008-11-30 21:37:12 +0100936void stream_sock_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200937{
Willy Tarreaub0253252008-11-30 21:37:12 +0100938 struct buffer *ib = si->ib;
939 struct buffer *ob = si->ob;
940 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200941
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100942 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200943 now_ms, __FUNCTION__,
944 fd, fdtab[fd].owner,
945 ib, ob,
946 ib->rex, ob->wex,
947 ib->flags, ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100948 ib->i, ib->o, ob->i, ob->o, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200949
950 /* Check if we need to close the read side */
951 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200952 /* Read not closed, update FD status and timeout for reads */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200953 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200954 /* stop reading */
Willy Tarreau11f49402010-11-11 23:08:17 +0100955 if (!(si->flags & SI_FL_WAIT_ROOM)) {
956 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
957 si->flags |= SI_FL_WAIT_ROOM;
958 EV_FD_COND_C(fd, DIR_RD);
959 ib->rex = TICK_ETERNITY;
960 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200961 }
962 else {
963 /* (re)start reading and update timeout. Note: we don't recompute the timeout
964 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200965 * update it if is was not yet set. The stream socket handler will already
966 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200967 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100968 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200969 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200970 if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
Willy Tarreau2d212792008-08-27 21:41:35 +0200971 ib->rex = tick_add_ifset(now_ms, ib->rto);
972 }
973 }
974
975 /* Check if we need to close the write side */
976 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200977 /* Write not closed, update FD status and timeout for writes */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200978 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200979 /* stop writing */
Willy Tarreau11f49402010-11-11 23:08:17 +0100980 if (!(si->flags & SI_FL_WAIT_DATA)) {
981 if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
982 si->flags |= SI_FL_WAIT_DATA;
983 EV_FD_COND_C(fd, DIR_WR);
984 ob->wex = TICK_ETERNITY;
985 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200986 }
987 else {
988 /* (re)start writing and update timeout. Note: we don't recompute the timeout
989 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200990 * update it if is was not yet set. The stream socket handler will already
991 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200992 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100993 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200994 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200995 if (!tick_isset(ob->wex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200996 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200997 if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200998 /* Note: depending on the protocol, we don't know if we're waiting
999 * for incoming data or not. So in order to prevent the socket from
1000 * expiring read timeouts during writes, we refresh the read timeout,
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001001 * except if it was already infinite or if we have explicitly setup
1002 * independant streams.
Willy Tarreau2d212792008-08-27 21:41:35 +02001003 */
Willy Tarreaud06e7112009-03-29 10:18:41 +02001004 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +02001005 }
1006 }
1007 }
1008 }
Willy Tarreau2d212792008-08-27 21:41:35 +02001009}
1010
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001011/* This function is used for inter-stream-interface calls. It is called by the
1012 * consumer to inform the producer side that it may be interested in checking
1013 * for free space in the buffer. Note that it intentionally does not update
1014 * timeouts, so that we can still check them later at wake-up.
1015 */
1016void stream_sock_chk_rcv(struct stream_interface *si)
1017{
1018 struct buffer *ib = si->ib;
1019
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001020 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001021 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001022 si->fd, fdtab[si->fd].owner,
1023 ib, si->ob,
1024 ib->rex, si->ob->wex,
1025 ib->flags, si->ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001026 ib->i, ib->o, si->ob->i, si->ob->o, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001027
1028 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
1029 return;
1030
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001031 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001032 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001033 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001034 si->flags |= SI_FL_WAIT_ROOM;
1035 EV_FD_COND_C(si->fd, DIR_RD);
1036 }
1037 else {
1038 /* (re)start reading */
1039 si->flags &= ~SI_FL_WAIT_ROOM;
1040 EV_FD_COND_S(si->fd, DIR_RD);
1041 }
1042}
1043
1044
1045/* This function is used for inter-stream-interface calls. It is called by the
1046 * producer to inform the consumer side that it may be interested in checking
1047 * for data in the buffer. Note that it intentionally does not update timeouts,
1048 * so that we can still check them later at wake-up.
1049 */
1050void stream_sock_chk_snd(struct stream_interface *si)
1051{
1052 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001053 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001054
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001055 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001056 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001057 si->fd, fdtab[si->fd].owner,
1058 si->ib, ob,
1059 si->ib->rex, ob->wex,
1060 si->ib->flags, ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001061 si->ib->i, si->ib->o, ob->i, ob->o, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001062
1063 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1064 return;
1065
Willy Tarreaueb9fd512011-12-11 22:11:47 +01001066 if (unlikely((ob->flags & BF_OUT_EMPTY) && !(si->send_proxy_ofs))) /* called with nothing to send ! */
1067 return;
1068
1069 if (!ob->pipe && /* spliced data wants to be forwarded ASAP */
1070 (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1071 (fdtab[si->fd].ev & FD_POLL_OUT))) /* we'll be called anyway */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001072 return;
1073
1074 retval = stream_sock_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001075 /* here, we have :
1076 * retval < 0 if an error was encountered during write.
1077 * retval = 0 if we can't write anymore without polling
1078 * retval = 1 if we're invited to come back when desired
1079 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001080 if (retval < 0) {
1081 /* Write error on the file descriptor. We mark the FD as STERROR so
1082 * that we don't use it anymore and we notify the task.
1083 */
1084 fdtab[si->fd].state = FD_STERROR;
1085 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001086 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001087 si->flags |= SI_FL_ERR;
1088 goto out_wakeup;
1089 }
Willy Tarreau68f49da2011-03-28 23:17:54 +02001090 else if (retval == 0 && si->send_proxy_ofs)
1091 goto out_may_wakeup; /* we failed to send the PROXY string */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001092
Willy Tarreauc54aef32009-07-27 20:08:06 +02001093 /* OK, so now we know that retval >= 0 means that some data might have
1094 * been sent, and that we may have to poll first. We have to do that
1095 * too if the buffer is not empty.
1096 */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001097 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001098 /* the connection is established but we can't write. Either the
1099 * buffer is empty, or we just refrain from sending because the
Willy Tarreau2e046c62012-03-01 16:08:30 +01001100 * ->o limit was reached. Maybe we just wrote the last
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001101 * chunk and need to close.
1102 */
Willy Tarreau520d95e2009-09-19 21:04:57 +02001103 if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
1104 (BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001105 (si->state == SI_ST_EST)) {
1106 stream_sock_shutw(si);
1107 goto out_wakeup;
1108 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001109
Willy Tarreau59454bf2009-09-20 11:13:40 +02001110 if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001111 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001112 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001113 }
1114 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +02001115 /* Otherwise there are remaining data to be sent in the buffer,
1116 * which means we have to poll before doing so.
1117 */
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001118 EV_FD_COND_S(si->fd, DIR_WR);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001119 si->flags &= ~SI_FL_WAIT_DATA;
1120 if (!tick_isset(ob->wex))
1121 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001122 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001123
Willy Tarreau68f49da2011-03-28 23:17:54 +02001124 out_may_wakeup:
Willy Tarreauc9619462009-03-09 22:40:57 +01001125 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1126 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001127 if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreauc9619462009-03-09 22:40:57 +01001128 ob->wex = tick_add_ifset(now_ms, ob->wto);
1129
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001130 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreauc9619462009-03-09 22:40:57 +01001131 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001132 * during writes, we refresh it. We only do this if the
1133 * interface is not configured for "independant streams",
1134 * because for some applications it's better not to do this,
1135 * for instance when continuously exchanging small amounts
1136 * of data which can full the socket buffers long before a
1137 * write timeout is detected.
Willy Tarreauc9619462009-03-09 22:40:57 +01001138 */
1139 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1140 }
1141 }
1142
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001143 /* in case of special condition (error, shutdown, end of write...), we
1144 * have to notify the task.
1145 */
1146 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001147 ((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001148 si->state != SI_ST_EST)) {
1149 out_wakeup:
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001150 if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
1151 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001152 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001153}
1154
Willy Tarreaueb472682010-05-28 18:46:57 +02001155/* This function is called on a read event from a listening socket, corresponding
1156 * to an accept. It tries to accept as many connections as possible, and for each
1157 * calls the listener's accept handler (generally the frontend's accept handler).
1158 */
1159int stream_sock_accept(int fd)
1160{
1161 struct listener *l = fdtab[fd].owner;
1162 struct proxy *p = l->frontend;
1163 int max_accept = global.tune.maxaccept;
1164 int cfd;
1165 int ret;
1166
1167 if (unlikely(l->nbconn >= l->maxconn)) {
Willy Tarreau62793712011-07-24 19:23:38 +02001168 listener_full(l);
Willy Tarreaueb472682010-05-28 18:46:57 +02001169 return 0;
1170 }
1171
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001172 if (global.cps_lim && !(l->options & LI_O_UNLIMITED)) {
Willy Tarreau81c25d02011-09-07 15:17:21 +02001173 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
1174
1175 if (unlikely(!max)) {
1176 /* frontend accept rate limit was reached */
1177 limit_listener(l, &global_listener_queue);
1178 task_schedule(global_listener_queue_task, tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0)));
1179 return 0;
1180 }
1181
1182 if (max_accept > max)
1183 max_accept = max;
1184 }
1185
Willy Tarreaueb472682010-05-28 18:46:57 +02001186 if (p && p->fe_sps_lim) {
1187 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
Willy Tarreau07687c12011-07-24 23:55:06 +02001188
1189 if (unlikely(!max)) {
1190 /* frontend accept rate limit was reached */
1191 limit_listener(l, &p->listener_queue);
Willy Tarreau918ff602011-07-25 16:33:49 +02001192 task_schedule(p->task, tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0)));
Willy Tarreau07687c12011-07-24 23:55:06 +02001193 return 0;
1194 }
1195
Willy Tarreaueb472682010-05-28 18:46:57 +02001196 if (max_accept > max)
1197 max_accept = max;
1198 }
1199
Willy Tarreaue9b26022011-08-01 20:57:55 +02001200 /* Note: if we fail to allocate a connection because of configured
1201 * limits, we'll schedule a new attempt worst 1 second later in the
1202 * worst case. If we fail due to system limits or temporary resource
1203 * shortage, we try again 100ms later in the worst case.
1204 */
Willy Tarreau07687c12011-07-24 23:55:06 +02001205 while (max_accept--) {
Willy Tarreaueb472682010-05-28 18:46:57 +02001206 struct sockaddr_storage addr;
1207 socklen_t laddr = sizeof(addr);
1208
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001209 if (unlikely(actconn >= global.maxconn) && !(l->options & LI_O_UNLIMITED)) {
Willy Tarreau07687c12011-07-24 23:55:06 +02001210 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001211 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreau07687c12011-07-24 23:55:06 +02001212 return 0;
1213 }
1214
1215 if (unlikely(p && p->feconn >= p->maxconn)) {
1216 limit_listener(l, &p->listener_queue);
1217 return 0;
1218 }
1219
Willy Tarreaueb472682010-05-28 18:46:57 +02001220 cfd = accept(fd, (struct sockaddr *)&addr, &laddr);
1221 if (unlikely(cfd == -1)) {
1222 switch (errno) {
1223 case EAGAIN:
1224 case EINTR:
1225 case ECONNABORTED:
1226 return 0; /* nothing more to accept */
1227 case ENFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001228 if (p)
1229 send_log(p, LOG_EMERG,
1230 "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
1231 p->id, maxfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001232 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001233 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreaueb472682010-05-28 18:46:57 +02001234 return 0;
1235 case EMFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001236 if (p)
1237 send_log(p, LOG_EMERG,
1238 "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
1239 p->id, maxfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001240 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001241 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreaueb472682010-05-28 18:46:57 +02001242 return 0;
1243 case ENOBUFS:
1244 case ENOMEM:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001245 if (p)
1246 send_log(p, LOG_EMERG,
1247 "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
1248 p->id, maxfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001249 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001250 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreaueb472682010-05-28 18:46:57 +02001251 return 0;
1252 default:
1253 return 0;
1254 }
1255 }
1256
1257 if (unlikely(cfd >= global.maxsock)) {
Willy Tarreaufffe1322010-11-11 09:48:16 +01001258 send_log(p, LOG_EMERG,
1259 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
1260 p->id);
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001261 close(cfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001262 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001263 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001264 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001265 }
1266
Willy Tarreau81c25d02011-09-07 15:17:21 +02001267 /* increase the per-process number of cumulated connections */
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001268 if (!(l->options & LI_O_UNLIMITED)) {
1269 update_freq_ctr(&global.conn_per_sec, 1);
1270 if (global.conn_per_sec.curr_ctr > global.cps_max)
1271 global.cps_max = global.conn_per_sec.curr_ctr;
1272 actconn++;
1273 }
Willy Tarreau81c25d02011-09-07 15:17:21 +02001274
Willy Tarreauaf7ad002010-08-31 15:39:26 +02001275 jobs++;
Willy Tarreau24dcaf32010-06-05 10:49:41 +02001276 totalconn++;
1277 l->nbconn++;
1278
1279 if (l->counters) {
1280 if (l->nbconn > l->counters->conn_max)
1281 l->counters->conn_max = l->nbconn;
1282 }
1283
Willy Tarreaueb472682010-05-28 18:46:57 +02001284 ret = l->accept(l, cfd, &addr);
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001285 if (unlikely(ret <= 0)) {
1286 /* The connection was closed by session_accept(). Either
1287 * we just have to ignore it (ret == 0) or it's a critical
1288 * error due to a resource shortage, and we must stop the
1289 * listener (ret < 0).
1290 */
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001291 if (!(l->options & LI_O_UNLIMITED))
1292 actconn--;
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001293 jobs--;
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001294 l->nbconn--;
1295 if (ret == 0) /* successful termination */
1296 continue;
1297
Willy Tarreau08ceb102011-07-24 22:58:00 +02001298 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001299 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001300 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001301 }
1302
Willy Tarreaueb472682010-05-28 18:46:57 +02001303 if (l->nbconn >= l->maxconn) {
Willy Tarreau62793712011-07-24 19:23:38 +02001304 listener_full(l);
Willy Tarreauff45b8c2011-07-24 19:16:52 +02001305 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001306 }
Willy Tarreau62793712011-07-24 19:23:38 +02001307
Willy Tarreaueb472682010-05-28 18:46:57 +02001308 } /* end of while (p->feconn < p->maxconn) */
Willy Tarreau08ceb102011-07-24 22:58:00 +02001309
Willy Tarreaueb472682010-05-28 18:46:57 +02001310 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001311}
1312
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001313
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001314/* Prepare a stream interface to be used in socket mode. */
1315void stream_sock_prepare_interface(struct stream_interface *si)
1316{
1317 si->update = stream_sock_data_finish;
1318 si->shutr = stream_sock_shutr;
1319 si->shutw = stream_sock_shutw;
1320 si->chk_rcv = stream_sock_chk_rcv;
1321 si->chk_snd = stream_sock_chk_snd;
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001322}
1323
Willy Tarreaubaaee002006-06-26 02:48:02 +02001324
1325/*
1326 * Local variables:
1327 * c-indent-level: 8
1328 * c-basic-offset: 8
1329 * End:
1330 */