blob: 11e74fdbb48b2f3e7a737c9b18081fdeab64772e [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{
76 int fd = si->fd;
Willy Tarreau31971e52009-09-20 12:07:52 +020077 int ret;
78 unsigned long max;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010079 int retval = 1;
80
81 if (!b->to_forward)
82 return -1;
83
84 if (!(b->flags & BF_KERN_SPLICING))
85 return -1;
86
87 if (b->l) {
88 /* We're embarrassed, there are already data pending in
89 * the buffer and we don't want to have them at two
90 * locations at a time. Let's indicate we need some
91 * place and ask the consumer to hurry.
92 */
93 si->flags |= SI_FL_WAIT_ROOM;
94 EV_FD_CLR(fd, DIR_RD);
95 b->rex = TICK_ETERNITY;
96 b->cons->chk_snd(b->cons);
97 return 1;
98 }
99
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100100 if (unlikely(b->pipe == NULL)) {
101 if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100102 b->flags &= ~BF_KERN_SPLICING;
103 return -1;
104 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100105 }
106
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100107 /* At this point, b->pipe is valid */
108
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100109 while (1) {
Willy Tarreaua9de3332009-11-28 07:47:10 +0100110 if (b->to_forward == BUF_INFINITE_FORWARD)
111 max = MAX_SPLICE_AT_ONCE;
112 else
113 max = b->to_forward;
114
Willy Tarreau31971e52009-09-20 12:07:52 +0200115 if (!max) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100116 /* It looks like the buffer + the pipe already contain
117 * the maximum amount of data to be transferred. Try to
118 * send those data immediately on the other side if it
119 * is currently waiting.
120 */
121 retval = -1; /* end of forwarding */
122 break;
123 }
124
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100125 ret = splice(fd, NULL, b->pipe->prod, NULL, max,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100126 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
127
128 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100129 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100130 /* connection closed. This is only detected by
131 * recent kernels (>= 2.6.27.13).
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100132 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100133 b->flags |= BF_READ_NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100134 retval = 1; /* no need for further polling */
135 break;
136 }
137
138 if (errno == EAGAIN) {
139 /* there are two reasons for EAGAIN :
140 * - nothing in the socket buffer (standard)
141 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100142 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100143 * Since we don't know if pipe is full, we'll
144 * stop if the pipe is not empty. Anyway, we
145 * will almost always fill/empty the pipe.
146 */
147
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100148 if (b->pipe->data) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100149 si->flags |= SI_FL_WAIT_ROOM;
150 retval = 1;
151 break;
152 }
153
Willy Tarreau98b306b2009-01-25 11:11:32 +0100154 /* We don't know if the connection was closed.
155 * But if we're called upon POLLIN with an empty
156 * pipe and get EAGAIN, it is suspect enought to
157 * try to fall back to the normal recv scheme
158 * which will be able to deal with the situation.
159 */
160 retval = -1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100161 break;
162 }
Willy Tarreaudc340a92009-06-28 23:10:19 +0200163
Willy Tarreaua9de3332009-11-28 07:47:10 +0100164 if (errno == ENOSYS || errno == EINVAL) {
Willy Tarreaudc340a92009-06-28 23:10:19 +0200165 /* splice not supported on this end, disable it */
166 b->flags &= ~BF_KERN_SPLICING;
167 si->flags &= ~SI_FL_CAP_SPLICE;
168 put_pipe(b->pipe);
169 b->pipe = NULL;
170 return -1;
171 }
172
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100173 /* here we have another error */
174 si->flags |= SI_FL_ERR;
175 retval = 1;
176 break;
177 } /* ret <= 0 */
178
Willy Tarreau31971e52009-09-20 12:07:52 +0200179 if (b->to_forward != BUF_INFINITE_FORWARD)
180 b->to_forward -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100181 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100182 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100183 b->flags |= BF_READ_PARTIAL;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200184 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100185
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100186 if (b->pipe->data >= SPLICE_FULL_HINT ||
187 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100188 /* We've read enough of it for this time. */
189 retval = 1;
190 break;
191 }
192 } /* while */
193
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100194 if (unlikely(!b->pipe->data)) {
195 put_pipe(b->pipe);
196 b->pipe = NULL;
197 }
198
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100199 return retval;
200}
201
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100202#endif /* CONFIG_HAP_LINUX_SPLICE */
203
204
Willy Tarreaubaaee002006-06-26 02:48:02 +0200205/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200206 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200207 * It returns 0 if we have a high confidence that we will not be
208 * able to read more data without polling first. Returns non-zero
209 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200210 */
Willy Tarreaud7971282006-07-29 18:36:34 +0200211int stream_sock_read(int fd) {
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200212 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200213 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200214 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100215 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200216
217#ifdef DEBUG_FULL
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100218 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 +0200219#endif
220
Willy Tarreau83749182007-04-15 20:56:27 +0200221 retval = 1;
222
Willy Tarreau71543652009-07-14 19:55:05 +0200223 /* stop immediately on errors. Note that we DON'T want to stop on
224 * POLL_ERR, as the poller might report a write error while there
225 * are still data available in the recv buffer. This typically
226 * happens when we send too large a request to a backend server
227 * which rejects it before reading it all.
228 */
229 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200230 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100231
232 /* stop here if we reached the end of data */
233 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
234 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200235
Willy Tarreaud06e7112009-03-29 10:18:41 +0200236 /* maybe we were called immediately after an asynchronous shutr */
237 if (b->flags & BF_SHUTR)
238 goto out_wakeup;
239
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100240#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau14acc702011-05-11 20:47:24 +0200241 if (b->to_forward >= MIN_SPLICE_FORWARD && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100242
243 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
244 * Since older splice() implementations were buggy and returned
245 * EAGAIN on end of read, let's bypass the call to splice() now.
246 */
247 if (fdtab[fd].ev & FD_POLL_HUP)
248 goto out_shutdown_r;
249
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100250 retval = stream_sock_splice_in(b, si);
251
252 if (retval >= 0) {
253 if (si->flags & SI_FL_ERR)
254 goto out_error;
255 if (b->flags & BF_READ_NULL)
256 goto out_shutdown_r;
257 goto out_wakeup;
258 }
259 /* splice not possible (anymore), let's go on on standard copy */
260 }
261#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200262 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200263 while (1) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100264 max = buffer_max_len(b) - b->l;
265
266 if (max <= 0) {
267 b->flags |= BF_FULL;
268 si->flags |= SI_FL_WAIT_ROOM;
269 break;
270 }
271
Willy Tarreau6996e152007-04-30 14:37:43 +0200272 /*
273 * 1. compute the maximum block size we can read at once.
274 */
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100275 if (b->l == 0) {
276 /* let's realign the buffer to optimize I/O */
277 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200278 }
279 else if (b->r > b->w) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100280 /* remaining space wraps at the end, with a moving limit */
281 if (max > b->data + b->size - b->r)
282 max = b->data + b->size - b->r;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100283 }
Willy Tarreau864e8252009-12-28 17:36:37 +0100284 /* else max is already OK */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200285
Willy Tarreau6996e152007-04-30 14:37:43 +0200286 /*
287 * 2. read the largest possible block
288 */
Willy Tarreaufc1daaf2010-01-15 10:26:13 +0100289 ret = recv(fd, b->r, max, 0);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200290
Willy Tarreau83749182007-04-15 20:56:27 +0200291 if (ret > 0) {
292 b->r += ret;
293 b->l += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200294 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100295
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100296 /* if we're allowed to directly forward data, we must update send_max */
Willy Tarreau31971e52009-09-20 12:07:52 +0200297 if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
298 unsigned long fwd = ret;
299 if (b->to_forward != BUF_INFINITE_FORWARD) {
300 if (fwd > b->to_forward)
301 fwd = b->to_forward;
302 b->to_forward -= fwd;
303 }
304 b->send_max += fwd;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200305 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100306 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100307
Willy Tarreaub38903c2008-11-23 21:33:29 +0100308 if (fdtab[fd].state == FD_STCONN)
309 fdtab[fd].state = FD_STREADY;
310
Willy Tarreau3da77c52008-08-29 09:58:42 +0200311 b->flags |= BF_READ_PARTIAL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100312
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200313 if (b->r == b->data + b->size) {
Willy Tarreau83749182007-04-15 20:56:27 +0200314 b->r = b->data; /* wrap around the buffer */
315 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100316
Willy Tarreau83749182007-04-15 20:56:27 +0200317 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100318
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100319 if (b->l >= buffer_max_len(b)) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200320 /* The buffer is now full, there's no point in going through
321 * the loop again.
322 */
Willy Tarreau8a7af602008-05-03 23:07:14 +0200323 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) {
324 b->xfer_small = 0;
325 b->xfer_large++;
326 if (b->xfer_large >= 3) {
327 /* we call this buffer a fast streamer if it manages
328 * to be filled in one call 3 consecutive times.
329 */
330 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
331 //fputc('+', stderr);
332 }
333 }
334 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200335 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200336 b->xfer_large = 0;
337 b->xfer_small++;
338 if (b->xfer_small >= 2) {
339 /* if the buffer has been at least half full twice,
340 * we receive faster than we send, so at least it
341 * is not a "fast streamer".
342 */
343 b->flags &= ~BF_STREAMER_FAST;
344 //fputc('-', stderr);
345 }
346 }
347 else {
348 b->xfer_small = 0;
349 b->xfer_large = 0;
350 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100351
352 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100353 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100354 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200355 }
356
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200357 /* if too many bytes were missing from last read, it means that
358 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100359 * not have them in buffers. BTW, if FD_POLL_HUP was present,
360 * it means that we have reached the end and that the connection
361 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200362 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100363 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200364 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200365 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200366 b->xfer_large = 0;
367 b->xfer_small++;
368 if (b->xfer_small >= 3) {
369 /* we have read less than half of the buffer in
370 * one pass, and this happened at least 3 times.
371 * This is definitely not a streamer.
372 */
373 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
374 //fputc('!', stderr);
375 }
376 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200377 /* unfortunately, on level-triggered events, POLL_HUP
378 * is generally delivered AFTER the system buffer is
379 * empty, so this one might never match.
380 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100381 if (fdtab[fd].ev & FD_POLL_HUP)
382 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200383
384 /* if a streamer has read few data, it may be because we
385 * have exhausted system buffers. It's not worth trying
386 * again.
387 */
388 if (b->flags & BF_STREAMER)
389 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200390
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100391 /* generally if we read something smaller than 1 or 2 MSS,
392 * it means that either we have exhausted the system's
393 * buffers (streamer or question-response protocol) or
394 * that the connection will be closed. Streamers are
395 * easily detected so we return early. For other cases,
396 * it's still better to perform a last read to be sure,
397 * because it may save one complete poll/read/wakeup cycle
398 * in case of shutdown.
399 */
400 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
401 break;
402
403 /* if we read a large block smaller than what we requested,
404 * it's almost certain we'll never get anything more.
405 */
406 if (ret >= global.tune.recv_enough)
407 break;
408 }
Willy Tarreau83749182007-04-15 20:56:27 +0200409
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100410 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200411 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200412 }
413 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200414 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100415 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200416 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200417 else if (errno == EAGAIN) {
418 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100419 * nothing to read left if we did not read much, ie
420 * less than what we were still expecting to read.
421 * But we may have done some work justifying to notify
422 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200423 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100424 if (cur_read < MIN_RET_FOR_READ_LOOP)
425 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200426 break;
427 }
428 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200429 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200430 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200431 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200432
Willy Tarreau6996e152007-04-30 14:37:43 +0200433 out_wakeup:
Willy Tarreau22be90b2011-05-11 20:32:36 +0200434 /* We might have some data the consumer is waiting for.
435 * We can do fast-forwarding, but we avoid doing this for partial
436 * buffers, because it is very likely that it will be done again
437 * immediately afterwards once the following data is parsed (eg:
438 * HTTP chunking).
439 */
440 if ((b->pipe || b->send_max == b->l)
441 && (b->cons->flags & SI_FL_WAIT_DATA)) {
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100442 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100443
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100444 b->cons->chk_snd(b->cons);
445
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100446 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100447 if (!(b->flags & BF_FULL) &&
448 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100449 si->flags &= ~SI_FL_WAIT_ROOM;
450 }
451
452 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100453 EV_FD_CLR(fd, DIR_RD);
454 b->rex = TICK_ETERNITY;
455 }
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200456 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 +0100457 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100458
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100459 /* we have to wake up if there is a special event or if we don't have
460 * any more data to forward.
461 */
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200462 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100463 si->state != SI_ST_EST ||
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200464 (si->flags & SI_FL_ERR) ||
465 ((b->flags & BF_READ_PARTIAL) && (!b->to_forward || b->cons->state != SI_ST_EST)))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100466 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200467
468 if (b->flags & BF_READ_ACTIVITY)
469 b->flags &= ~BF_READ_DONTWAIT;
470
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100471 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200472 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200473
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100474 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200475 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100476 fdtab[fd].ev &= ~FD_POLL_HUP;
477 b->flags |= BF_READ_NULL;
Willy Tarreau520d95e2009-09-19 21:04:57 +0200478 if (b->flags & BF_AUTO_CLOSE)
Willy Tarreau418fd472009-09-06 21:37:23 +0200479 buffer_shutw_now(b);
Willy Tarreau99126c32008-11-27 10:30:51 +0100480 stream_sock_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200481 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100482
Willy Tarreau6996e152007-04-30 14:37:43 +0200483 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100484 /* Read error on the file descriptor. We mark the FD as STERROR so
485 * that we don't use it anymore. The error is reported to the stream
486 * interface which will take proper action. We must not perturbate the
487 * buffer because the stream interface wants to ensure transparent
488 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200489 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100490
Willy Tarreau6996e152007-04-30 14:37:43 +0200491 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100492 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100493 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100494 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100495 retval = 1;
496 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200497}
498
499
500/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100501 * This function is called to send buffer data to a stream socket.
502 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100503 * before calling it again, otherwise 1. If a pipe was associated with the
504 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200505 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100506static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100507{
Willy Tarreau83749182007-04-15 20:56:27 +0200508 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100509 int retval = 1;
510 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200511
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100512 if (unlikely(si->send_proxy_ofs)) {
513 /* The target server expects a PROXY line to be sent first.
514 * If the send_proxy_ofs is negative, it corresponds to the
515 * offset to start sending from then end of the proxy string
516 * (which is recomputed every time since it's constant). If
517 * it is positive, it means we have to send from the start.
518 */
519 ret = make_proxy_line(trash, sizeof(trash),
520 &b->prod->addr.c.from, &b->prod->addr.c.to);
521 if (!ret)
522 return -1;
523
524 if (si->send_proxy_ofs > 0)
525 si->send_proxy_ofs = -ret; /* first call */
526
527 /* we have to send trash from (ret+sp for -sp bytes) */
528 ret = send(si->fd, trash + ret + si->send_proxy_ofs, -si->send_proxy_ofs,
529 (b->flags & BF_OUT_EMPTY) ? 0 : MSG_MORE);
530 if (ret > 0) {
531 if (fdtab[si->fd].state == FD_STCONN)
532 fdtab[si->fd].state = FD_STREADY;
533
534 si->send_proxy_ofs += ret; /* becomes zero once complete */
535 b->flags |= BF_WRITE_NULL; /* connect() succeeded */
536 }
537 else if (ret == 0 || errno == EAGAIN) {
538 /* nothing written, we need to poll for write first */
539 return 0;
540 }
541 else {
542 /* bad, we got an error */
543 return -1;
544 }
545 }
546
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100547#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100548 while (b->pipe) {
549 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100550 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
551 if (ret <= 0) {
552 if (ret == 0 || errno == EAGAIN) {
553 retval = 0;
554 return retval;
555 }
556 /* here we have another error */
557 retval = -1;
558 return retval;
559 }
560
561 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100562 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100563
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100564 if (!b->pipe->data) {
565 put_pipe(b->pipe);
566 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100567 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100568 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100569
570 if (--write_poll <= 0)
571 return retval;
572 }
573
574 /* At this point, the pipe is empty, but we may still have data pending
575 * in the normal buffer.
576 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100577#endif
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200578 if (!b->send_max) {
579 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100580 return retval;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200581 }
Willy Tarreau83749182007-04-15 20:56:27 +0200582
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100583 /* when we're in this loop, we already know that there is no spliced
584 * data left, and that there are sendable buffered data.
585 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200586 while (1) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100587 if (b->r > b->w)
Willy Tarreau83749182007-04-15 20:56:27 +0200588 max = b->r - b->w;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100589 else
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200590 max = b->data + b->size - b->w;
Willy Tarreau83749182007-04-15 20:56:27 +0200591
Willy Tarreauf890dc92008-12-13 21:12:26 +0100592 /* limit the amount of outgoing data if required */
593 if (max > b->send_max)
594 max = b->send_max;
595
Willy Tarreau6db06d32009-08-19 11:14:11 +0200596 /* check if we want to inform the kernel that we're interested in
597 * sending more data after this call. We want this if :
598 * - we're about to close after this last send and want to merge
599 * the ongoing FIN with the last segment.
600 * - we know we can't send everything at once and must get back
601 * here because of unaligned data
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100602 * - there is still a finite amount of data to forward
Willy Tarreau6db06d32009-08-19 11:14:11 +0200603 * The test is arranged so that the most common case does only 2
604 * tests.
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200605 */
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200606
Willy Tarreauface8392010-01-03 11:37:54 +0100607 if (MSG_NOSIGNAL && MSG_MORE) {
Willy Tarreau6db06d32009-08-19 11:14:11 +0200608 unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
609
Willy Tarreau96e31212011-05-30 18:10:30 +0200610 if ((!(b->flags & BF_NEVER_WAIT) &&
611 ((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
612 (b->flags & BF_EXPECT_MORE))) ||
Willy Tarreauf8ca19b2011-05-30 17:32:53 +0200613 ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->send_max)) ||
614 (max != b->l && max != b->send_max)) {
Willy Tarreauface8392010-01-03 11:37:54 +0100615 send_flag |= MSG_MORE;
616 }
Willy Tarreau6db06d32009-08-19 11:14:11 +0200617
Willy Tarreau2be39392010-01-03 17:24:51 +0100618 /* this flag has precedence over the rest */
619 if (b->flags & BF_SEND_DONTWAIT)
620 send_flag &= ~MSG_MORE;
621
Willy Tarreau6db06d32009-08-19 11:14:11 +0200622 ret = send(si->fd, b->w, max, send_flag);
Willy Tarreau2be39392010-01-03 17:24:51 +0100623
Willy Tarreau8f8b4922011-05-11 20:14:03 +0200624 /* Always clear both flags once everything has been sent */
625 if (ret == max)
626 b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200627 } else {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200628 int skerr;
629 socklen_t lskerr = sizeof(skerr);
630
Willy Tarreau87bed622009-03-08 22:25:28 +0100631 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200632 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200633 ret = -1;
634 else
Willy Tarreau87bed622009-03-08 22:25:28 +0100635 ret = send(si->fd, b->w, max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200636 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200637
638 if (ret > 0) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100639 if (fdtab[si->fd].state == FD_STCONN)
640 fdtab[si->fd].state = FD_STREADY;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100641
Willy Tarreau3da77c52008-08-29 09:58:42 +0200642 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200643
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100644 b->w += ret;
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200645 if (b->w == b->data + b->size)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100646 b->w = b->data; /* wrap around the buffer */
647
648 b->l -= ret;
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100649 if (likely(b->l < buffer_max_len(b)))
Willy Tarreaue393fe22008-08-16 22:18:07 +0200650 b->flags &= ~BF_FULL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100651
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200652 if (likely(!b->l))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100653 /* optimize data alignment in the buffer */
654 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200655
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100656 b->send_max -= ret;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200657 if (!b->send_max) {
658 if (likely(!b->pipe))
659 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100660 break;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200661 }
Willy Tarreau83749182007-04-15 20:56:27 +0200662
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200663 /* if the system buffer is full, don't insist */
664 if (ret < max)
665 break;
666
Willy Tarreau6996e152007-04-30 14:37:43 +0200667 if (--write_poll <= 0)
668 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200669 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200670 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100671 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200672 retval = 0;
673 break;
674 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200675 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100676 /* bad, we got an error */
677 retval = -1;
678 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200679 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200680 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200681
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100682 return retval;
683}
Willy Tarreau6996e152007-04-30 14:37:43 +0200684
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100685
686/*
687 * This function is called on a write event from a stream socket.
688 * It returns 0 if the caller needs to poll before calling it again, otherwise
689 * non-zero.
690 */
691int stream_sock_write(int fd)
692{
693 struct stream_interface *si = fdtab[fd].owner;
694 struct buffer *b = si->ob;
695 int retval = 1;
696
697#ifdef DEBUG_FULL
698 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
699#endif
700
701 retval = 1;
Willy Tarreau71543652009-07-14 19:55:05 +0200702 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100703 goto out_error;
704
Willy Tarreaud06e7112009-03-29 10:18:41 +0200705 /* we might have been called just after an asynchronous shutw */
706 if (b->flags & BF_SHUTW)
707 goto out_wakeup;
708
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100709 if (likely(!(b->flags & BF_OUT_EMPTY) || si->send_proxy_ofs)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100710 /* OK there are data waiting to be sent */
711 retval = stream_sock_write_loop(si, b);
712 if (retval < 0)
713 goto out_error;
Willy Tarreau68f49da2011-03-28 23:17:54 +0200714 else if (retval == 0 && si->send_proxy_ofs)
715 goto out_may_wakeup; /* we failed to send the PROXY string */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200716 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100717 else {
718 /* may be we have received a connection acknowledgement in TCP mode without data */
719 if (likely(fdtab[fd].state == FD_STCONN)) {
720 /* We have no data to send to check the connection, and
721 * getsockopt() will not inform us whether the connection
722 * is still pending. So we'll reuse connect() to check the
723 * state of the socket. This has the advantage of givig us
724 * the following info :
725 * - error
726 * - connecting (EALREADY, EINPROGRESS)
727 * - connected (EISCONN, 0)
728 */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +0200729 if ((connect(fd, fdinfo[fd].peeraddr, fdinfo[fd].peerlen) == 0))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100730 errno = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200731
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100732 if (errno == EALREADY || errno == EINPROGRESS) {
733 retval = 0;
734 goto out_may_wakeup;
735 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100736
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100737 if (errno && errno != EISCONN)
738 goto out_error;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200739
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100740 /* OK we just need to indicate that we got a connection
741 * and that we wrote nothing.
742 */
743 b->flags |= BF_WRITE_NULL;
744 fdtab[fd].state = FD_STREADY;
745 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200746
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100747 /* Funny, we were called to write something but there wasn't
748 * anything. We can get there, for example if we were woken up
749 * on a write event to finish the splice, but the send_max is 0
750 * so we cannot write anything from the buffer. Let's disable
751 * the write event and pretend we never came there.
752 */
753 }
754
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200755 if (b->flags & BF_OUT_EMPTY) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100756 /* the connection is established but we can't write. Either the
757 * buffer is empty, or we just refrain from sending because the
758 * send_max limit was reached. Maybe we just wrote the last
759 * chunk and need to close.
760 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200761 if (((b->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100762 (si->state == SI_ST_EST)) {
763 stream_sock_shutw(si);
764 goto out_wakeup;
765 }
766
Willy Tarreau59454bf2009-09-20 11:13:40 +0200767 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreauac128fe2009-01-09 13:05:19 +0100768 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100769
Willy Tarreauac128fe2009-01-09 13:05:19 +0100770 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100771 b->wex = TICK_ETERNITY;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100772 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100773
774 out_may_wakeup:
775 if (b->flags & BF_WRITE_ACTIVITY) {
776 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200777 if ((b->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100778 b->wex = tick_add_ifset(now_ms, b->wto);
779
780 out_wakeup:
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200781 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100782 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200783 * during writes, we refresh it. We only do this if the
784 * interface is not configured for "independant streams",
785 * because for some applications it's better not to do this,
786 * for instance when continuously exchanging small amounts
787 * of data which can full the socket buffers long before a
788 * write timeout is detected.
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100789 */
790 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
791 }
792
793 /* the producer might be waiting for more room to store data */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200794 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100795 (b->prod->flags & SI_FL_WAIT_ROOM)))
796 b->prod->chk_rcv(b->prod);
797
798 /* we have to wake up if there is a special event or if we don't have
799 * any more data to forward and it's not planned to send any more.
800 */
801 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200802 ((b->flags & BF_OUT_EMPTY) && !b->to_forward) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100803 si->state != SI_ST_EST ||
804 b->prod->state != SI_ST_EST))
805 task_wakeup(si->owner, TASK_WOKEN_IO);
806 }
807
808 fdtab[fd].ev &= ~FD_POLL_OUT;
809 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100810
Willy Tarreau6996e152007-04-30 14:37:43 +0200811 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100812 /* Write error on the file descriptor. We mark the FD as STERROR so
813 * that we don't use it anymore. The error is reported to the stream
814 * interface which will take proper action. We must not perturbate the
815 * buffer because the stream interface wants to ensure transparent
816 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200817 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100818
Willy Tarreau6996e152007-04-30 14:37:43 +0200819 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100820 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100821 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100822 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200823 task_wakeup(si->owner, TASK_WOKEN_IO);
824 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200825}
826
Willy Tarreau48adac52008-08-30 04:58:38 +0200827/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200828 * This function performs a shutdown-write on a stream interface in a connected or
829 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100830 * or closes the file descriptor and marks itself as closed. The buffer flags are
Willy Tarreau7340ca52010-01-16 10:03:45 +0100831 * updated to reflect the new state. It does also close everything is the SI was
832 * marked as being in error state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200833 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100834void stream_sock_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200835{
Willy Tarreau418fd472009-09-06 21:37:23 +0200836 si->ob->flags &= ~BF_SHUTW_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100837 if (si->ob->flags & BF_SHUTW)
838 return;
839 si->ob->flags |= BF_SHUTW;
840 si->ob->wex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100841 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau99126c32008-11-27 10:30:51 +0100842
Willy Tarreaub38903c2008-11-23 21:33:29 +0100843 switch (si->state) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100844 case SI_ST_EST:
Willy Tarreau720058c2009-07-14 19:21:50 +0200845 /* we have to shut before closing, otherwise some short messages
846 * may never leave the system, especially when there are remaining
847 * unread data in the socket input buffer, or when nolinger is set.
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100848 * However, if SI_FL_NOLINGER is explicitly set, we know there is
849 * no risk so we close both sides immediately.
Willy Tarreau720058c2009-07-14 19:21:50 +0200850 */
Willy Tarreau7340ca52010-01-16 10:03:45 +0100851 if (si->flags & SI_FL_ERR) {
852 /* quick close, the socket is already shut. Remove pending flags. */
853 si->flags &= ~SI_FL_NOLINGER;
854 } else if (si->flags & SI_FL_NOLINGER) {
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100855 si->flags &= ~SI_FL_NOLINGER;
856 setsockopt(si->fd, SOL_SOCKET, SO_LINGER,
857 (struct linger *) &nolinger, sizeof(struct linger));
858 } else {
859 EV_FD_CLR(si->fd, DIR_WR);
860 shutdown(si->fd, SHUT_WR);
Willy Tarreau720058c2009-07-14 19:21:50 +0200861
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100862 if (!(si->ib->flags & (BF_SHUTR|BF_DONT_READ)))
863 return;
864 }
Willy Tarreau5d707e12009-06-28 11:09:07 +0200865
Willy Tarreaub38903c2008-11-23 21:33:29 +0100866 /* fall through */
867 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100868 /* we may have to close a pending connection, and mark the
869 * response buffer as shutr
870 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200871 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100872 /* fall through */
873 case SI_ST_CER:
Willy Tarreau32d3ee92010-12-29 14:03:02 +0100874 case SI_ST_QUE:
875 case SI_ST_TAR:
Willy Tarreau7f006512008-12-07 14:04:04 +0100876 si->state = SI_ST_DIS;
877 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200878 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100879 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100880 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100881 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100882 return;
Willy Tarreau48adac52008-08-30 04:58:38 +0200883 }
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200884
885 if (si->release)
886 si->release(si);
Willy Tarreau48adac52008-08-30 04:58:38 +0200887}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200888
Willy Tarreau2d212792008-08-27 21:41:35 +0200889/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200890 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100891 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100892 * or closes the file descriptor and marks itself as closed. The buffer flags are
893 * updated to reflect the new state.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200894 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100895void stream_sock_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200896{
Willy Tarreau418fd472009-09-06 21:37:23 +0200897 si->ib->flags &= ~BF_SHUTR_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100898 if (si->ib->flags & BF_SHUTR)
899 return;
900 si->ib->flags |= BF_SHUTR;
901 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100902 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100903
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100904 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100905 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200906
Willy Tarreaucff64112008-11-03 06:26:53 +0100907 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200908 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100909 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100910 si->exp = TICK_ETERNITY;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200911
912 if (si->release)
913 si->release(si);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100914 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200915 }
916 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100917 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200918}
919
920/*
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200921 * Updates a connected stream_sock file descriptor status and timeouts
922 * according to the buffers' flags. It should only be called once after the
923 * buffer flags have settled down, and before they are cleared. It doesn't
924 * harm to call it as often as desired (it just slightly hurts performance).
925 */
Willy Tarreaub0253252008-11-30 21:37:12 +0100926void stream_sock_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200927{
Willy Tarreaub0253252008-11-30 21:37:12 +0100928 struct buffer *ib = si->ib;
929 struct buffer *ob = si->ob;
930 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200931
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200932 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n",
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200933 now_ms, __FUNCTION__,
934 fd, fdtab[fd].owner,
935 ib, ob,
936 ib->rex, ob->wex,
937 ib->flags, ob->flags,
Willy Tarreaub0253252008-11-30 21:37:12 +0100938 ib->l, ob->l, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200939
940 /* Check if we need to close the read side */
941 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200942 /* Read not closed, update FD status and timeout for reads */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200943 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200944 /* stop reading */
Willy Tarreau11f49402010-11-11 23:08:17 +0100945 if (!(si->flags & SI_FL_WAIT_ROOM)) {
946 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
947 si->flags |= SI_FL_WAIT_ROOM;
948 EV_FD_COND_C(fd, DIR_RD);
949 ib->rex = TICK_ETERNITY;
950 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200951 }
952 else {
953 /* (re)start reading and update timeout. Note: we don't recompute the timeout
954 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200955 * update it if is was not yet set. The stream socket handler will already
956 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200957 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100958 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200959 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200960 if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
Willy Tarreau2d212792008-08-27 21:41:35 +0200961 ib->rex = tick_add_ifset(now_ms, ib->rto);
962 }
963 }
964
965 /* Check if we need to close the write side */
966 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200967 /* Write not closed, update FD status and timeout for writes */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200968 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200969 /* stop writing */
Willy Tarreau11f49402010-11-11 23:08:17 +0100970 if (!(si->flags & SI_FL_WAIT_DATA)) {
971 if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
972 si->flags |= SI_FL_WAIT_DATA;
973 EV_FD_COND_C(fd, DIR_WR);
974 ob->wex = TICK_ETERNITY;
975 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200976 }
977 else {
978 /* (re)start writing and update timeout. Note: we don't recompute the timeout
979 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200980 * update it if is was not yet set. The stream socket handler will already
981 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200982 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100983 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200984 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200985 if (!tick_isset(ob->wex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200986 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200987 if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200988 /* Note: depending on the protocol, we don't know if we're waiting
989 * for incoming data or not. So in order to prevent the socket from
990 * expiring read timeouts during writes, we refresh the read timeout,
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200991 * except if it was already infinite or if we have explicitly setup
992 * independant streams.
Willy Tarreau2d212792008-08-27 21:41:35 +0200993 */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200994 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +0200995 }
996 }
997 }
998 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200999}
1000
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001001/* This function is used for inter-stream-interface calls. It is called by the
1002 * consumer to inform the producer side that it may be interested in checking
1003 * for free space in the buffer. Note that it intentionally does not update
1004 * timeouts, so that we can still check them later at wake-up.
1005 */
1006void stream_sock_chk_rcv(struct stream_interface *si)
1007{
1008 struct buffer *ib = si->ib;
1009
1010 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n",
1011 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001012 si->fd, fdtab[si->fd].owner,
1013 ib, si->ob,
1014 ib->rex, si->ob->wex,
1015 ib->flags, si->ob->flags,
1016 ib->l, si->ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001017
1018 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
1019 return;
1020
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001021 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001022 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001023 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001024 si->flags |= SI_FL_WAIT_ROOM;
1025 EV_FD_COND_C(si->fd, DIR_RD);
1026 }
1027 else {
1028 /* (re)start reading */
1029 si->flags &= ~SI_FL_WAIT_ROOM;
1030 EV_FD_COND_S(si->fd, DIR_RD);
1031 }
1032}
1033
1034
1035/* This function is used for inter-stream-interface calls. It is called by the
1036 * producer to inform the consumer side that it may be interested in checking
1037 * for data in the buffer. Note that it intentionally does not update timeouts,
1038 * so that we can still check them later at wake-up.
1039 */
1040void stream_sock_chk_snd(struct stream_interface *si)
1041{
1042 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001043 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001044
1045 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n",
1046 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001047 si->fd, fdtab[si->fd].owner,
1048 si->ib, ob,
1049 si->ib->rex, ob->wex,
1050 si->ib->flags, ob->flags,
1051 si->ib->l, ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001052
1053 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1054 return;
1055
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001056 if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1057 (fdtab[si->fd].ev & FD_POLL_OUT) || /* we'll be called anyway */
Willy Tarreaub22e55b2011-03-20 10:16:46 +01001058 ((ob->flags & BF_OUT_EMPTY) && !(si->send_proxy_ofs))) /* called with nothing to send ! */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001059 return;
1060
1061 retval = stream_sock_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001062 /* here, we have :
1063 * retval < 0 if an error was encountered during write.
1064 * retval = 0 if we can't write anymore without polling
1065 * retval = 1 if we're invited to come back when desired
1066 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001067 if (retval < 0) {
1068 /* Write error on the file descriptor. We mark the FD as STERROR so
1069 * that we don't use it anymore and we notify the task.
1070 */
1071 fdtab[si->fd].state = FD_STERROR;
1072 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001073 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001074 si->flags |= SI_FL_ERR;
1075 goto out_wakeup;
1076 }
Willy Tarreau68f49da2011-03-28 23:17:54 +02001077 else if (retval == 0 && si->send_proxy_ofs)
1078 goto out_may_wakeup; /* we failed to send the PROXY string */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001079
Willy Tarreauc54aef32009-07-27 20:08:06 +02001080 /* OK, so now we know that retval >= 0 means that some data might have
1081 * been sent, and that we may have to poll first. We have to do that
1082 * too if the buffer is not empty.
1083 */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001084 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001085 /* the connection is established but we can't write. Either the
1086 * buffer is empty, or we just refrain from sending because the
1087 * send_max limit was reached. Maybe we just wrote the last
1088 * chunk and need to close.
1089 */
Willy Tarreau520d95e2009-09-19 21:04:57 +02001090 if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
1091 (BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001092 (si->state == SI_ST_EST)) {
1093 stream_sock_shutw(si);
1094 goto out_wakeup;
1095 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001096
Willy Tarreau59454bf2009-09-20 11:13:40 +02001097 if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001098 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001099 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001100 }
1101 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +02001102 /* Otherwise there are remaining data to be sent in the buffer,
1103 * which means we have to poll before doing so.
1104 */
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001105 EV_FD_COND_S(si->fd, DIR_WR);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001106 si->flags &= ~SI_FL_WAIT_DATA;
1107 if (!tick_isset(ob->wex))
1108 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001109 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001110
Willy Tarreau68f49da2011-03-28 23:17:54 +02001111 out_may_wakeup:
Willy Tarreauc9619462009-03-09 22:40:57 +01001112 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1113 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001114 if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreauc9619462009-03-09 22:40:57 +01001115 ob->wex = tick_add_ifset(now_ms, ob->wto);
1116
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001117 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreauc9619462009-03-09 22:40:57 +01001118 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001119 * during writes, we refresh it. We only do this if the
1120 * interface is not configured for "independant streams",
1121 * because for some applications it's better not to do this,
1122 * for instance when continuously exchanging small amounts
1123 * of data which can full the socket buffers long before a
1124 * write timeout is detected.
Willy Tarreauc9619462009-03-09 22:40:57 +01001125 */
1126 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1127 }
1128 }
1129
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001130 /* in case of special condition (error, shutdown, end of write...), we
1131 * have to notify the task.
1132 */
1133 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001134 ((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001135 si->state != SI_ST_EST)) {
1136 out_wakeup:
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001137 if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
1138 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001139 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001140}
1141
Willy Tarreaueb472682010-05-28 18:46:57 +02001142/* This function is called on a read event from a listening socket, corresponding
1143 * to an accept. It tries to accept as many connections as possible, and for each
1144 * calls the listener's accept handler (generally the frontend's accept handler).
1145 */
1146int stream_sock_accept(int fd)
1147{
1148 struct listener *l = fdtab[fd].owner;
1149 struct proxy *p = l->frontend;
1150 int max_accept = global.tune.maxaccept;
1151 int cfd;
1152 int ret;
1153
1154 if (unlikely(l->nbconn >= l->maxconn)) {
Willy Tarreau62793712011-07-24 19:23:38 +02001155 listener_full(l);
Willy Tarreaueb472682010-05-28 18:46:57 +02001156 return 0;
1157 }
1158
1159 if (p && p->fe_sps_lim) {
1160 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
Willy Tarreau07687c12011-07-24 23:55:06 +02001161
1162 if (unlikely(!max)) {
1163 /* frontend accept rate limit was reached */
1164 limit_listener(l, &p->listener_queue);
Willy Tarreau918ff602011-07-25 16:33:49 +02001165 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 +02001166 return 0;
1167 }
1168
Willy Tarreaueb472682010-05-28 18:46:57 +02001169 if (max_accept > max)
1170 max_accept = max;
1171 }
1172
Willy Tarreaue9b26022011-08-01 20:57:55 +02001173 /* Note: if we fail to allocate a connection because of configured
1174 * limits, we'll schedule a new attempt worst 1 second later in the
1175 * worst case. If we fail due to system limits or temporary resource
1176 * shortage, we try again 100ms later in the worst case.
1177 */
Willy Tarreau07687c12011-07-24 23:55:06 +02001178 while (max_accept--) {
Willy Tarreaueb472682010-05-28 18:46:57 +02001179 struct sockaddr_storage addr;
1180 socklen_t laddr = sizeof(addr);
1181
Willy Tarreau07687c12011-07-24 23:55:06 +02001182 if (unlikely(actconn >= global.maxconn)) {
1183 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001184 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreau07687c12011-07-24 23:55:06 +02001185 return 0;
1186 }
1187
1188 if (unlikely(p && p->feconn >= p->maxconn)) {
1189 limit_listener(l, &p->listener_queue);
1190 return 0;
1191 }
1192
Willy Tarreaueb472682010-05-28 18:46:57 +02001193 cfd = accept(fd, (struct sockaddr *)&addr, &laddr);
1194 if (unlikely(cfd == -1)) {
1195 switch (errno) {
1196 case EAGAIN:
1197 case EINTR:
1198 case ECONNABORTED:
1199 return 0; /* nothing more to accept */
1200 case ENFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001201 if (p)
1202 send_log(p, LOG_EMERG,
1203 "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
1204 p->id, maxfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001205 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001206 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreaueb472682010-05-28 18:46:57 +02001207 return 0;
1208 case EMFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001209 if (p)
1210 send_log(p, LOG_EMERG,
1211 "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
1212 p->id, maxfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001213 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001214 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreaueb472682010-05-28 18:46:57 +02001215 return 0;
1216 case ENOBUFS:
1217 case ENOMEM:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001218 if (p)
1219 send_log(p, LOG_EMERG,
1220 "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
1221 p->id, maxfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001222 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001223 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreaueb472682010-05-28 18:46:57 +02001224 return 0;
1225 default:
1226 return 0;
1227 }
1228 }
1229
1230 if (unlikely(cfd >= global.maxsock)) {
Willy Tarreaufffe1322010-11-11 09:48:16 +01001231 send_log(p, LOG_EMERG,
1232 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
1233 p->id);
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001234 close(cfd);
Willy Tarreau08ceb102011-07-24 22:58:00 +02001235 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001236 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001237 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001238 }
1239
Willy Tarreauaf7ad002010-08-31 15:39:26 +02001240 jobs++;
Willy Tarreau24dcaf32010-06-05 10:49:41 +02001241 actconn++;
1242 totalconn++;
1243 l->nbconn++;
1244
1245 if (l->counters) {
1246 if (l->nbconn > l->counters->conn_max)
1247 l->counters->conn_max = l->nbconn;
1248 }
1249
Willy Tarreaueb472682010-05-28 18:46:57 +02001250 ret = l->accept(l, cfd, &addr);
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001251 if (unlikely(ret <= 0)) {
1252 /* The connection was closed by session_accept(). Either
1253 * we just have to ignore it (ret == 0) or it's a critical
1254 * error due to a resource shortage, and we must stop the
1255 * listener (ret < 0).
1256 */
1257 jobs--;
1258 actconn--;
1259 l->nbconn--;
1260 if (ret == 0) /* successful termination */
1261 continue;
1262
Willy Tarreau08ceb102011-07-24 22:58:00 +02001263 limit_listener(l, &global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02001264 task_schedule(global_listener_queue_task, tick_add(now_ms, 100)); /* try again in 100 ms */
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001265 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001266 }
1267
Willy Tarreaueb472682010-05-28 18:46:57 +02001268 if (l->nbconn >= l->maxconn) {
Willy Tarreau62793712011-07-24 19:23:38 +02001269 listener_full(l);
Willy Tarreauff45b8c2011-07-24 19:16:52 +02001270 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001271 }
Willy Tarreau62793712011-07-24 19:23:38 +02001272
Willy Tarreaueb472682010-05-28 18:46:57 +02001273 } /* end of while (p->feconn < p->maxconn) */
Willy Tarreau08ceb102011-07-24 22:58:00 +02001274
Willy Tarreaueb472682010-05-28 18:46:57 +02001275 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001276}
1277
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001278
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001279/* Prepare a stream interface to be used in socket mode. */
1280void stream_sock_prepare_interface(struct stream_interface *si)
1281{
1282 si->update = stream_sock_data_finish;
1283 si->shutr = stream_sock_shutr;
1284 si->shutw = stream_sock_shutw;
1285 si->chk_rcv = stream_sock_chk_rcv;
1286 si->chk_snd = stream_sock_chk_snd;
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001287}
1288
Willy Tarreaubaaee002006-06-26 02:48:02 +02001289
1290/*
1291 * Local variables:
1292 * c-indent-level: 8
1293 * c-basic-offset: 8
1294 * End:
1295 */