blob: 845aca08cc8dc4cae69b72833ceaf0d10c6194e0 [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/* On recent Linux kernels, the splice() syscall may be used for faster data copy.
45 * But it's not always defined on some OS versions, and it even happens that some
46 * definitions are wrong with some glibc due to an offset bug in syscall().
47 */
48
49#if defined(CONFIG_HAP_LINUX_SPLICE)
50#include <unistd.h>
51#include <sys/syscall.h>
52
53#ifndef SPLICE_F_MOVE
54#define SPLICE_F_MOVE 0x1
55#endif
56
57#ifndef SPLICE_F_NONBLOCK
58#define SPLICE_F_NONBLOCK 0x2
59#endif
60
61#ifndef SPLICE_F_MORE
62#define SPLICE_F_MORE 0x4
63#endif
64
65#ifndef __NR_splice
66#if defined(__powerpc__) || defined(__powerpc64__)
67#define __NR_splice 283
68#elif defined(__sparc__) || defined(__sparc64__)
69#define __NR_splice 232
70#elif defined(__x86_64__)
71#define __NR_splice 275
72#elif defined(__alpha__)
73#define __NR_splice 468
74#elif defined (__i386__)
75#define __NR_splice 313
76#else
77#warning unsupported architecture, guessing __NR_splice=313 like x86...
78#define __NR_splice 313
79#endif /* $arch */
80
Willy Tarreau48d84c12010-11-14 17:09:33 +010081#if defined(CONFIG_HAP_LINUX_VSYSCALL) && defined(__linux__) && defined(__i386__)
82/* the syscall is redefined somewhere else */
83extern int splice(int fdin, loff_t *off_in, int fdout, loff_t *off_out, size_t len, unsigned long flags);
84#else
Willy Tarreau6b4aad42009-01-18 21:59:13 +010085_syscall6(int, splice, int, fdin, loff_t *, off_in, int, fdout, loff_t *, off_out, size_t, len, unsigned long, flags)
Willy Tarreau48d84c12010-11-14 17:09:33 +010086#endif
Willy Tarreau6b4aad42009-01-18 21:59:13 +010087#endif /* __NR_splice */
Willy Tarreau5bd8c372009-01-19 00:32:22 +010088
89/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
90 * because of timestamps. Use this as a hint for not looping on splice().
91 */
92#define SPLICE_FULL_HINT 16*1448
93
Willy Tarreaua9de3332009-11-28 07:47:10 +010094/* how many data we attempt to splice at once when the buffer is configured for
95 * infinite forwarding */
96#define MAX_SPLICE_AT_ONCE (1<<30)
97
Willy Tarreau5bd8c372009-01-19 00:32:22 +010098/* Returns :
99 * -1 if splice is not possible or not possible anymore and we must switch to
100 * user-land copy (eg: to_forward reached)
101 * 0 when we know that polling is required to get more data (EAGAIN)
102 * 1 for all other cases (we can safely try again, or if an activity has been
103 * detected (DATA/NULL/ERR))
104 * Sets :
105 * BF_READ_NULL
106 * BF_READ_PARTIAL
107 * BF_WRITE_PARTIAL (during copy)
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200108 * BF_OUT_EMPTY (during copy)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100109 * SI_FL_ERR
110 * SI_FL_WAIT_ROOM
111 * (SI_FL_WAIT_RECV)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100112 *
113 * This function automatically allocates a pipe from the pipe pool. It also
114 * carefully ensures to clear b->pipe whenever it leaves the pipe empty.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100115 */
116static int stream_sock_splice_in(struct buffer *b, struct stream_interface *si)
117{
118 int fd = si->fd;
Willy Tarreau31971e52009-09-20 12:07:52 +0200119 int ret;
120 unsigned long max;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100121 int retval = 1;
122
123 if (!b->to_forward)
124 return -1;
125
126 if (!(b->flags & BF_KERN_SPLICING))
127 return -1;
128
129 if (b->l) {
130 /* We're embarrassed, there are already data pending in
131 * the buffer and we don't want to have them at two
132 * locations at a time. Let's indicate we need some
133 * place and ask the consumer to hurry.
134 */
135 si->flags |= SI_FL_WAIT_ROOM;
136 EV_FD_CLR(fd, DIR_RD);
137 b->rex = TICK_ETERNITY;
138 b->cons->chk_snd(b->cons);
139 return 1;
140 }
141
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100142 if (unlikely(b->pipe == NULL)) {
143 if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100144 b->flags &= ~BF_KERN_SPLICING;
145 return -1;
146 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100147 }
148
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100149 /* At this point, b->pipe is valid */
150
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100151 while (1) {
Willy Tarreaua9de3332009-11-28 07:47:10 +0100152 if (b->to_forward == BUF_INFINITE_FORWARD)
153 max = MAX_SPLICE_AT_ONCE;
154 else
155 max = b->to_forward;
156
Willy Tarreau31971e52009-09-20 12:07:52 +0200157 if (!max) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100158 /* It looks like the buffer + the pipe already contain
159 * the maximum amount of data to be transferred. Try to
160 * send those data immediately on the other side if it
161 * is currently waiting.
162 */
163 retval = -1; /* end of forwarding */
164 break;
165 }
166
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100167 ret = splice(fd, NULL, b->pipe->prod, NULL, max,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100168 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
169
170 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100171 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100172 /* connection closed. This is only detected by
173 * recent kernels (>= 2.6.27.13).
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100174 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100175 b->flags |= BF_READ_NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100176 retval = 1; /* no need for further polling */
177 break;
178 }
179
180 if (errno == EAGAIN) {
181 /* there are two reasons for EAGAIN :
182 * - nothing in the socket buffer (standard)
183 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100184 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100185 * Since we don't know if pipe is full, we'll
186 * stop if the pipe is not empty. Anyway, we
187 * will almost always fill/empty the pipe.
188 */
189
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100190 if (b->pipe->data) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100191 si->flags |= SI_FL_WAIT_ROOM;
192 retval = 1;
193 break;
194 }
195
Willy Tarreau98b306b2009-01-25 11:11:32 +0100196 /* We don't know if the connection was closed.
197 * But if we're called upon POLLIN with an empty
198 * pipe and get EAGAIN, it is suspect enought to
199 * try to fall back to the normal recv scheme
200 * which will be able to deal with the situation.
201 */
202 retval = -1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100203 break;
204 }
Willy Tarreaudc340a92009-06-28 23:10:19 +0200205
Willy Tarreaua9de3332009-11-28 07:47:10 +0100206 if (errno == ENOSYS || errno == EINVAL) {
Willy Tarreaudc340a92009-06-28 23:10:19 +0200207 /* splice not supported on this end, disable it */
208 b->flags &= ~BF_KERN_SPLICING;
209 si->flags &= ~SI_FL_CAP_SPLICE;
210 put_pipe(b->pipe);
211 b->pipe = NULL;
212 return -1;
213 }
214
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100215 /* here we have another error */
216 si->flags |= SI_FL_ERR;
217 retval = 1;
218 break;
219 } /* ret <= 0 */
220
Willy Tarreau31971e52009-09-20 12:07:52 +0200221 if (b->to_forward != BUF_INFINITE_FORWARD)
222 b->to_forward -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100223 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100224 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100225 b->flags |= BF_READ_PARTIAL;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200226 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100227
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100228 if (b->pipe->data >= SPLICE_FULL_HINT ||
229 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100230 /* We've read enough of it for this time. */
231 retval = 1;
232 break;
233 }
234 } /* while */
235
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100236 if (unlikely(!b->pipe->data)) {
237 put_pipe(b->pipe);
238 b->pipe = NULL;
239 }
240
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100241 return retval;
242}
243
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100244#endif /* CONFIG_HAP_LINUX_SPLICE */
245
246
Willy Tarreaubaaee002006-06-26 02:48:02 +0200247/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200248 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200249 * It returns 0 if we have a high confidence that we will not be
250 * able to read more data without polling first. Returns non-zero
251 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200252 */
Willy Tarreaud7971282006-07-29 18:36:34 +0200253int stream_sock_read(int fd) {
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200254 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200255 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200256 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100257 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200258
259#ifdef DEBUG_FULL
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100260 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 +0200261#endif
262
Willy Tarreau83749182007-04-15 20:56:27 +0200263 retval = 1;
264
Willy Tarreau71543652009-07-14 19:55:05 +0200265 /* stop immediately on errors. Note that we DON'T want to stop on
266 * POLL_ERR, as the poller might report a write error while there
267 * are still data available in the recv buffer. This typically
268 * happens when we send too large a request to a backend server
269 * which rejects it before reading it all.
270 */
271 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200272 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100273
274 /* stop here if we reached the end of data */
275 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
276 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200277
Willy Tarreaud06e7112009-03-29 10:18:41 +0200278 /* maybe we were called immediately after an asynchronous shutr */
279 if (b->flags & BF_SHUTR)
280 goto out_wakeup;
281
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100282#if defined(CONFIG_HAP_LINUX_SPLICE)
283 if (b->to_forward && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100284
285 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
286 * Since older splice() implementations were buggy and returned
287 * EAGAIN on end of read, let's bypass the call to splice() now.
288 */
289 if (fdtab[fd].ev & FD_POLL_HUP)
290 goto out_shutdown_r;
291
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100292 retval = stream_sock_splice_in(b, si);
293
294 if (retval >= 0) {
295 if (si->flags & SI_FL_ERR)
296 goto out_error;
297 if (b->flags & BF_READ_NULL)
298 goto out_shutdown_r;
299 goto out_wakeup;
300 }
301 /* splice not possible (anymore), let's go on on standard copy */
302 }
303#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200304 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200305 while (1) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100306 max = buffer_max_len(b) - b->l;
307
308 if (max <= 0) {
309 b->flags |= BF_FULL;
310 si->flags |= SI_FL_WAIT_ROOM;
311 break;
312 }
313
Willy Tarreau6996e152007-04-30 14:37:43 +0200314 /*
315 * 1. compute the maximum block size we can read at once.
316 */
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100317 if (b->l == 0) {
318 /* let's realign the buffer to optimize I/O */
319 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200320 }
321 else if (b->r > b->w) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100322 /* remaining space wraps at the end, with a moving limit */
323 if (max > b->data + b->size - b->r)
324 max = b->data + b->size - b->r;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100325 }
Willy Tarreau864e8252009-12-28 17:36:37 +0100326 /* else max is already OK */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200327
Willy Tarreau6996e152007-04-30 14:37:43 +0200328 /*
329 * 2. read the largest possible block
330 */
Willy Tarreaufc1daaf2010-01-15 10:26:13 +0100331 ret = recv(fd, b->r, max, 0);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200332
Willy Tarreau83749182007-04-15 20:56:27 +0200333 if (ret > 0) {
334 b->r += ret;
335 b->l += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200336 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100337
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100338 /* if we're allowed to directly forward data, we must update send_max */
Willy Tarreau31971e52009-09-20 12:07:52 +0200339 if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
340 unsigned long fwd = ret;
341 if (b->to_forward != BUF_INFINITE_FORWARD) {
342 if (fwd > b->to_forward)
343 fwd = b->to_forward;
344 b->to_forward -= fwd;
345 }
346 b->send_max += fwd;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200347 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100348 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100349
Willy Tarreaub38903c2008-11-23 21:33:29 +0100350 if (fdtab[fd].state == FD_STCONN)
351 fdtab[fd].state = FD_STREADY;
352
Willy Tarreau3da77c52008-08-29 09:58:42 +0200353 b->flags |= BF_READ_PARTIAL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100354
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200355 if (b->r == b->data + b->size) {
Willy Tarreau83749182007-04-15 20:56:27 +0200356 b->r = b->data; /* wrap around the buffer */
357 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100358
Willy Tarreau83749182007-04-15 20:56:27 +0200359 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100360
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100361 if (b->l >= buffer_max_len(b)) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200362 /* The buffer is now full, there's no point in going through
363 * the loop again.
364 */
Willy Tarreau8a7af602008-05-03 23:07:14 +0200365 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) {
366 b->xfer_small = 0;
367 b->xfer_large++;
368 if (b->xfer_large >= 3) {
369 /* we call this buffer a fast streamer if it manages
370 * to be filled in one call 3 consecutive times.
371 */
372 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
373 //fputc('+', stderr);
374 }
375 }
376 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200377 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200378 b->xfer_large = 0;
379 b->xfer_small++;
380 if (b->xfer_small >= 2) {
381 /* if the buffer has been at least half full twice,
382 * we receive faster than we send, so at least it
383 * is not a "fast streamer".
384 */
385 b->flags &= ~BF_STREAMER_FAST;
386 //fputc('-', stderr);
387 }
388 }
389 else {
390 b->xfer_small = 0;
391 b->xfer_large = 0;
392 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100393
394 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100395 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100396 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200397 }
398
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200399 /* if too many bytes were missing from last read, it means that
400 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100401 * not have them in buffers. BTW, if FD_POLL_HUP was present,
402 * it means that we have reached the end and that the connection
403 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200404 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100405 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200406 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200407 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200408 b->xfer_large = 0;
409 b->xfer_small++;
410 if (b->xfer_small >= 3) {
411 /* we have read less than half of the buffer in
412 * one pass, and this happened at least 3 times.
413 * This is definitely not a streamer.
414 */
415 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
416 //fputc('!', stderr);
417 }
418 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200419 /* unfortunately, on level-triggered events, POLL_HUP
420 * is generally delivered AFTER the system buffer is
421 * empty, so this one might never match.
422 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100423 if (fdtab[fd].ev & FD_POLL_HUP)
424 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200425
426 /* if a streamer has read few data, it may be because we
427 * have exhausted system buffers. It's not worth trying
428 * again.
429 */
430 if (b->flags & BF_STREAMER)
431 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200432
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100433 /* generally if we read something smaller than 1 or 2 MSS,
434 * it means that either we have exhausted the system's
435 * buffers (streamer or question-response protocol) or
436 * that the connection will be closed. Streamers are
437 * easily detected so we return early. For other cases,
438 * it's still better to perform a last read to be sure,
439 * because it may save one complete poll/read/wakeup cycle
440 * in case of shutdown.
441 */
442 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
443 break;
444
445 /* if we read a large block smaller than what we requested,
446 * it's almost certain we'll never get anything more.
447 */
448 if (ret >= global.tune.recv_enough)
449 break;
450 }
Willy Tarreau83749182007-04-15 20:56:27 +0200451
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100452 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200453 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200454 }
455 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200456 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100457 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200458 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200459 else if (errno == EAGAIN) {
460 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100461 * nothing to read left if we did not read much, ie
462 * less than what we were still expecting to read.
463 * But we may have done some work justifying to notify
464 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200465 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100466 if (cur_read < MIN_RET_FOR_READ_LOOP)
467 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200468 break;
469 }
470 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200471 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200472 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200473 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200474
Willy Tarreau6996e152007-04-30 14:37:43 +0200475 out_wakeup:
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100476 /* We might have some data the consumer is waiting for */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200477 if (!(b->flags & BF_OUT_EMPTY) && (b->cons->flags & SI_FL_WAIT_DATA)) {
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100478 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100479
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100480 b->cons->chk_snd(b->cons);
481
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100482 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100483 if (!(b->flags & BF_FULL) &&
484 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100485 si->flags &= ~SI_FL_WAIT_ROOM;
486 }
487
488 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100489 EV_FD_CLR(fd, DIR_RD);
490 b->rex = TICK_ETERNITY;
491 }
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200492 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 +0100493 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100494
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100495 /* we have to wake up if there is a special event or if we don't have
496 * any more data to forward.
497 */
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200498 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100499 si->state != SI_ST_EST ||
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200500 (si->flags & SI_FL_ERR) ||
501 ((b->flags & BF_READ_PARTIAL) && (!b->to_forward || b->cons->state != SI_ST_EST)))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100502 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200503
504 if (b->flags & BF_READ_ACTIVITY)
505 b->flags &= ~BF_READ_DONTWAIT;
506
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100507 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200508 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200509
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100510 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200511 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100512 fdtab[fd].ev &= ~FD_POLL_HUP;
513 b->flags |= BF_READ_NULL;
Willy Tarreau520d95e2009-09-19 21:04:57 +0200514 if (b->flags & BF_AUTO_CLOSE)
Willy Tarreau418fd472009-09-06 21:37:23 +0200515 buffer_shutw_now(b);
Willy Tarreau99126c32008-11-27 10:30:51 +0100516 stream_sock_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200517 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100518
Willy Tarreau6996e152007-04-30 14:37:43 +0200519 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100520 /* Read error on the file descriptor. We mark the FD as STERROR so
521 * that we don't use it anymore. The error is reported to the stream
522 * interface which will take proper action. We must not perturbate the
523 * buffer because the stream interface wants to ensure transparent
524 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200525 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100526
Willy Tarreau6996e152007-04-30 14:37:43 +0200527 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100528 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100529 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100530 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100531 retval = 1;
532 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200533}
534
535
536/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100537 * This function is called to send buffer data to a stream socket.
538 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100539 * before calling it again, otherwise 1. If a pipe was associated with the
540 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200541 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100542static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100543{
Willy Tarreau83749182007-04-15 20:56:27 +0200544 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100545 int retval = 1;
546 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200547
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100548 if (unlikely(si->send_proxy_ofs)) {
549 /* The target server expects a PROXY line to be sent first.
550 * If the send_proxy_ofs is negative, it corresponds to the
551 * offset to start sending from then end of the proxy string
552 * (which is recomputed every time since it's constant). If
553 * it is positive, it means we have to send from the start.
554 */
555 ret = make_proxy_line(trash, sizeof(trash),
556 &b->prod->addr.c.from, &b->prod->addr.c.to);
557 if (!ret)
558 return -1;
559
560 if (si->send_proxy_ofs > 0)
561 si->send_proxy_ofs = -ret; /* first call */
562
563 /* we have to send trash from (ret+sp for -sp bytes) */
564 ret = send(si->fd, trash + ret + si->send_proxy_ofs, -si->send_proxy_ofs,
565 (b->flags & BF_OUT_EMPTY) ? 0 : MSG_MORE);
566 if (ret > 0) {
567 if (fdtab[si->fd].state == FD_STCONN)
568 fdtab[si->fd].state = FD_STREADY;
569
570 si->send_proxy_ofs += ret; /* becomes zero once complete */
571 b->flags |= BF_WRITE_NULL; /* connect() succeeded */
572 }
573 else if (ret == 0 || errno == EAGAIN) {
574 /* nothing written, we need to poll for write first */
575 return 0;
576 }
577 else {
578 /* bad, we got an error */
579 return -1;
580 }
581 }
582
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100583#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100584 while (b->pipe) {
585 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100586 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
587 if (ret <= 0) {
588 if (ret == 0 || errno == EAGAIN) {
589 retval = 0;
590 return retval;
591 }
592 /* here we have another error */
593 retval = -1;
594 return retval;
595 }
596
597 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100598 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100599
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100600 if (!b->pipe->data) {
601 put_pipe(b->pipe);
602 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100603 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100604 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100605
606 if (--write_poll <= 0)
607 return retval;
608 }
609
610 /* At this point, the pipe is empty, but we may still have data pending
611 * in the normal buffer.
612 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100613#endif
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200614 if (!b->send_max) {
615 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100616 return retval;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200617 }
Willy Tarreau83749182007-04-15 20:56:27 +0200618
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100619 /* when we're in this loop, we already know that there is no spliced
620 * data left, and that there are sendable buffered data.
621 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200622 while (1) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100623 if (b->r > b->w)
Willy Tarreau83749182007-04-15 20:56:27 +0200624 max = b->r - b->w;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100625 else
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200626 max = b->data + b->size - b->w;
Willy Tarreau83749182007-04-15 20:56:27 +0200627
Willy Tarreauf890dc92008-12-13 21:12:26 +0100628 /* limit the amount of outgoing data if required */
629 if (max > b->send_max)
630 max = b->send_max;
631
Willy Tarreau6db06d32009-08-19 11:14:11 +0200632 /* check if we want to inform the kernel that we're interested in
633 * sending more data after this call. We want this if :
634 * - we're about to close after this last send and want to merge
635 * the ongoing FIN with the last segment.
636 * - we know we can't send everything at once and must get back
637 * here because of unaligned data
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100638 * - there is still a finite amount of data to forward
Willy Tarreau6db06d32009-08-19 11:14:11 +0200639 * The test is arranged so that the most common case does only 2
640 * tests.
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200641 */
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200642
Willy Tarreauface8392010-01-03 11:37:54 +0100643 if (MSG_NOSIGNAL && MSG_MORE) {
Willy Tarreau6db06d32009-08-19 11:14:11 +0200644 unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
645
Willy Tarreauface8392010-01-03 11:37:54 +0100646 if (((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100647 ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->send_max)) ||
Willy Tarreau6db06d32009-08-19 11:14:11 +0200648 (max != b->l && max != b->send_max))
649 && (fdtab[si->fd].flags & FD_FL_TCP)) {
650 send_flag |= MSG_MORE;
651 }
Willy Tarreauface8392010-01-03 11:37:54 +0100652 else if (b->flags & BF_EXPECT_MORE) {
653 /* it was forced on the buffer, this flag is one-shoot */
654 b->flags &= ~BF_EXPECT_MORE;
655 send_flag |= MSG_MORE;
656 }
Willy Tarreau6db06d32009-08-19 11:14:11 +0200657
Willy Tarreau2be39392010-01-03 17:24:51 +0100658 /* this flag has precedence over the rest */
659 if (b->flags & BF_SEND_DONTWAIT)
660 send_flag &= ~MSG_MORE;
661
Willy Tarreau6db06d32009-08-19 11:14:11 +0200662 ret = send(si->fd, b->w, max, send_flag);
Willy Tarreau2be39392010-01-03 17:24:51 +0100663
664 /* disable it only once everything has been sent */
665 if (ret == max && (b->flags & BF_SEND_DONTWAIT))
666 b->flags &= ~BF_SEND_DONTWAIT;
Willy Tarreaud6d06902009-08-19 11:22:33 +0200667 } else {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200668 int skerr;
669 socklen_t lskerr = sizeof(skerr);
670
Willy Tarreau87bed622009-03-08 22:25:28 +0100671 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200672 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200673 ret = -1;
674 else
Willy Tarreau87bed622009-03-08 22:25:28 +0100675 ret = send(si->fd, b->w, max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200676 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200677
678 if (ret > 0) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100679 if (fdtab[si->fd].state == FD_STCONN)
680 fdtab[si->fd].state = FD_STREADY;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100681
Willy Tarreau3da77c52008-08-29 09:58:42 +0200682 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200683
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100684 b->w += ret;
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200685 if (b->w == b->data + b->size)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100686 b->w = b->data; /* wrap around the buffer */
687
688 b->l -= ret;
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100689 if (likely(b->l < buffer_max_len(b)))
Willy Tarreaue393fe22008-08-16 22:18:07 +0200690 b->flags &= ~BF_FULL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100691
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200692 if (likely(!b->l))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100693 /* optimize data alignment in the buffer */
694 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200695
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100696 b->send_max -= ret;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200697 if (!b->send_max) {
698 if (likely(!b->pipe))
699 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100700 break;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200701 }
Willy Tarreau83749182007-04-15 20:56:27 +0200702
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200703 /* if the system buffer is full, don't insist */
704 if (ret < max)
705 break;
706
Willy Tarreau6996e152007-04-30 14:37:43 +0200707 if (--write_poll <= 0)
708 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200709 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200710 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100711 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200712 retval = 0;
713 break;
714 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200715 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100716 /* bad, we got an error */
717 retval = -1;
718 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200719 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200720 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200721
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100722 return retval;
723}
Willy Tarreau6996e152007-04-30 14:37:43 +0200724
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100725
726/*
727 * This function is called on a write event from a stream socket.
728 * It returns 0 if the caller needs to poll before calling it again, otherwise
729 * non-zero.
730 */
731int stream_sock_write(int fd)
732{
733 struct stream_interface *si = fdtab[fd].owner;
734 struct buffer *b = si->ob;
735 int retval = 1;
736
737#ifdef DEBUG_FULL
738 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
739#endif
740
741 retval = 1;
Willy Tarreau71543652009-07-14 19:55:05 +0200742 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100743 goto out_error;
744
Willy Tarreaud06e7112009-03-29 10:18:41 +0200745 /* we might have been called just after an asynchronous shutw */
746 if (b->flags & BF_SHUTW)
747 goto out_wakeup;
748
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100749 if (likely(!(b->flags & BF_OUT_EMPTY) || si->send_proxy_ofs)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100750 /* OK there are data waiting to be sent */
751 retval = stream_sock_write_loop(si, b);
752 if (retval < 0)
753 goto out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200754 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100755 else {
756 /* may be we have received a connection acknowledgement in TCP mode without data */
757 if (likely(fdtab[fd].state == FD_STCONN)) {
758 /* We have no data to send to check the connection, and
759 * getsockopt() will not inform us whether the connection
760 * is still pending. So we'll reuse connect() to check the
761 * state of the socket. This has the advantage of givig us
762 * the following info :
763 * - error
764 * - connecting (EALREADY, EINPROGRESS)
765 * - connected (EISCONN, 0)
766 */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +0200767 if ((connect(fd, fdinfo[fd].peeraddr, fdinfo[fd].peerlen) == 0))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100768 errno = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200769
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100770 if (errno == EALREADY || errno == EINPROGRESS) {
771 retval = 0;
772 goto out_may_wakeup;
773 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100774
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100775 if (errno && errno != EISCONN)
776 goto out_error;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200777
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100778 /* OK we just need to indicate that we got a connection
779 * and that we wrote nothing.
780 */
781 b->flags |= BF_WRITE_NULL;
782 fdtab[fd].state = FD_STREADY;
783 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200784
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100785 /* Funny, we were called to write something but there wasn't
786 * anything. We can get there, for example if we were woken up
787 * on a write event to finish the splice, but the send_max is 0
788 * so we cannot write anything from the buffer. Let's disable
789 * the write event and pretend we never came there.
790 */
791 }
792
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200793 if (b->flags & BF_OUT_EMPTY) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100794 /* the connection is established but we can't write. Either the
795 * buffer is empty, or we just refrain from sending because the
796 * send_max limit was reached. Maybe we just wrote the last
797 * chunk and need to close.
798 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200799 if (((b->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100800 (si->state == SI_ST_EST)) {
801 stream_sock_shutw(si);
802 goto out_wakeup;
803 }
804
Willy Tarreau59454bf2009-09-20 11:13:40 +0200805 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreauac128fe2009-01-09 13:05:19 +0100806 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100807
Willy Tarreauac128fe2009-01-09 13:05:19 +0100808 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100809 b->wex = TICK_ETERNITY;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100810 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100811
812 out_may_wakeup:
813 if (b->flags & BF_WRITE_ACTIVITY) {
814 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200815 if ((b->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100816 b->wex = tick_add_ifset(now_ms, b->wto);
817
818 out_wakeup:
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200819 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100820 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200821 * during writes, we refresh it. We only do this if the
822 * interface is not configured for "independant streams",
823 * because for some applications it's better not to do this,
824 * for instance when continuously exchanging small amounts
825 * of data which can full the socket buffers long before a
826 * write timeout is detected.
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100827 */
828 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
829 }
830
831 /* the producer might be waiting for more room to store data */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200832 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100833 (b->prod->flags & SI_FL_WAIT_ROOM)))
834 b->prod->chk_rcv(b->prod);
835
836 /* we have to wake up if there is a special event or if we don't have
837 * any more data to forward and it's not planned to send any more.
838 */
839 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200840 ((b->flags & BF_OUT_EMPTY) && !b->to_forward) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100841 si->state != SI_ST_EST ||
842 b->prod->state != SI_ST_EST))
843 task_wakeup(si->owner, TASK_WOKEN_IO);
844 }
845
846 fdtab[fd].ev &= ~FD_POLL_OUT;
847 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100848
Willy Tarreau6996e152007-04-30 14:37:43 +0200849 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100850 /* Write error on the file descriptor. We mark the FD as STERROR so
851 * that we don't use it anymore. The error is reported to the stream
852 * interface which will take proper action. We must not perturbate the
853 * buffer because the stream interface wants to ensure transparent
854 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200855 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100856
Willy Tarreau6996e152007-04-30 14:37:43 +0200857 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100858 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100859 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100860 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200861 task_wakeup(si->owner, TASK_WOKEN_IO);
862 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200863}
864
Willy Tarreau48adac52008-08-30 04:58:38 +0200865/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200866 * This function performs a shutdown-write on a stream interface in a connected or
867 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100868 * or closes the file descriptor and marks itself as closed. The buffer flags are
Willy Tarreau7340ca52010-01-16 10:03:45 +0100869 * updated to reflect the new state. It does also close everything is the SI was
870 * marked as being in error state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200871 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100872void stream_sock_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200873{
Willy Tarreau418fd472009-09-06 21:37:23 +0200874 si->ob->flags &= ~BF_SHUTW_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100875 if (si->ob->flags & BF_SHUTW)
876 return;
877 si->ob->flags |= BF_SHUTW;
878 si->ob->wex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100879 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau99126c32008-11-27 10:30:51 +0100880
Willy Tarreaub38903c2008-11-23 21:33:29 +0100881 switch (si->state) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100882 case SI_ST_EST:
Willy Tarreau720058c2009-07-14 19:21:50 +0200883 /* we have to shut before closing, otherwise some short messages
884 * may never leave the system, especially when there are remaining
885 * unread data in the socket input buffer, or when nolinger is set.
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100886 * However, if SI_FL_NOLINGER is explicitly set, we know there is
887 * no risk so we close both sides immediately.
Willy Tarreau720058c2009-07-14 19:21:50 +0200888 */
Willy Tarreau7340ca52010-01-16 10:03:45 +0100889 if (si->flags & SI_FL_ERR) {
890 /* quick close, the socket is already shut. Remove pending flags. */
891 si->flags &= ~SI_FL_NOLINGER;
892 } else if (si->flags & SI_FL_NOLINGER) {
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100893 si->flags &= ~SI_FL_NOLINGER;
894 setsockopt(si->fd, SOL_SOCKET, SO_LINGER,
895 (struct linger *) &nolinger, sizeof(struct linger));
896 } else {
897 EV_FD_CLR(si->fd, DIR_WR);
898 shutdown(si->fd, SHUT_WR);
Willy Tarreau720058c2009-07-14 19:21:50 +0200899
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100900 if (!(si->ib->flags & (BF_SHUTR|BF_DONT_READ)))
901 return;
902 }
Willy Tarreau5d707e12009-06-28 11:09:07 +0200903
Willy Tarreaub38903c2008-11-23 21:33:29 +0100904 /* fall through */
905 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100906 /* we may have to close a pending connection, and mark the
907 * response buffer as shutr
908 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200909 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100910 /* fall through */
911 case SI_ST_CER:
Willy Tarreau32d3ee92010-12-29 14:03:02 +0100912 case SI_ST_QUE:
913 case SI_ST_TAR:
Willy Tarreau7f006512008-12-07 14:04:04 +0100914 si->state = SI_ST_DIS;
915 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200916 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100917 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100918 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100919 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100920 return;
Willy Tarreau48adac52008-08-30 04:58:38 +0200921 }
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200922
923 if (si->release)
924 si->release(si);
Willy Tarreau48adac52008-08-30 04:58:38 +0200925}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200926
Willy Tarreau2d212792008-08-27 21:41:35 +0200927/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200928 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100929 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100930 * or closes the file descriptor and marks itself as closed. The buffer flags are
931 * updated to reflect the new state.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200932 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100933void stream_sock_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200934{
Willy Tarreau418fd472009-09-06 21:37:23 +0200935 si->ib->flags &= ~BF_SHUTR_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100936 if (si->ib->flags & BF_SHUTR)
937 return;
938 si->ib->flags |= BF_SHUTR;
939 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100940 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100941
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100942 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100943 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200944
Willy Tarreaucff64112008-11-03 06:26:53 +0100945 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200946 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100947 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100948 si->exp = TICK_ETERNITY;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200949
950 if (si->release)
951 si->release(si);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100952 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200953 }
954 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100955 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200956}
957
958/*
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200959 * Updates a connected stream_sock file descriptor status and timeouts
960 * according to the buffers' flags. It should only be called once after the
961 * buffer flags have settled down, and before they are cleared. It doesn't
962 * harm to call it as often as desired (it just slightly hurts performance).
963 */
Willy Tarreaub0253252008-11-30 21:37:12 +0100964void stream_sock_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200965{
Willy Tarreaub0253252008-11-30 21:37:12 +0100966 struct buffer *ib = si->ib;
967 struct buffer *ob = si->ob;
968 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200969
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200970 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 +0200971 now_ms, __FUNCTION__,
972 fd, fdtab[fd].owner,
973 ib, ob,
974 ib->rex, ob->wex,
975 ib->flags, ob->flags,
Willy Tarreaub0253252008-11-30 21:37:12 +0100976 ib->l, ob->l, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200977
978 /* Check if we need to close the read side */
979 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200980 /* Read not closed, update FD status and timeout for reads */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200981 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200982 /* stop reading */
Willy Tarreau11f49402010-11-11 23:08:17 +0100983 if (!(si->flags & SI_FL_WAIT_ROOM)) {
984 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
985 si->flags |= SI_FL_WAIT_ROOM;
986 EV_FD_COND_C(fd, DIR_RD);
987 ib->rex = TICK_ETERNITY;
988 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200989 }
990 else {
991 /* (re)start reading and update timeout. Note: we don't recompute the timeout
992 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200993 * update it if is was not yet set. The stream socket handler will already
994 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200995 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100996 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200997 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200998 if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
Willy Tarreau2d212792008-08-27 21:41:35 +0200999 ib->rex = tick_add_ifset(now_ms, ib->rto);
1000 }
1001 }
1002
1003 /* Check if we need to close the write side */
1004 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +02001005 /* Write not closed, update FD status and timeout for writes */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001006 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreau2d212792008-08-27 21:41:35 +02001007 /* stop writing */
Willy Tarreau11f49402010-11-11 23:08:17 +01001008 if (!(si->flags & SI_FL_WAIT_DATA)) {
1009 if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
1010 si->flags |= SI_FL_WAIT_DATA;
1011 EV_FD_COND_C(fd, DIR_WR);
1012 ob->wex = TICK_ETERNITY;
1013 }
Willy Tarreau2d212792008-08-27 21:41:35 +02001014 }
1015 else {
1016 /* (re)start writing and update timeout. Note: we don't recompute the timeout
1017 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +02001018 * update it if is was not yet set. The stream socket handler will already
1019 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +02001020 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +01001021 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +02001022 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreaufe8903c2009-10-04 10:56:08 +02001023 if (!tick_isset(ob->wex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +02001024 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001025 if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +02001026 /* Note: depending on the protocol, we don't know if we're waiting
1027 * for incoming data or not. So in order to prevent the socket from
1028 * expiring read timeouts during writes, we refresh the read timeout,
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001029 * except if it was already infinite or if we have explicitly setup
1030 * independant streams.
Willy Tarreau2d212792008-08-27 21:41:35 +02001031 */
Willy Tarreaud06e7112009-03-29 10:18:41 +02001032 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +02001033 }
1034 }
1035 }
1036 }
Willy Tarreau2d212792008-08-27 21:41:35 +02001037}
1038
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001039/* This function is used for inter-stream-interface calls. It is called by the
1040 * consumer to inform the producer side that it may be interested in checking
1041 * for free space in the buffer. Note that it intentionally does not update
1042 * timeouts, so that we can still check them later at wake-up.
1043 */
1044void stream_sock_chk_rcv(struct stream_interface *si)
1045{
1046 struct buffer *ib = si->ib;
1047
1048 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",
1049 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001050 si->fd, fdtab[si->fd].owner,
1051 ib, si->ob,
1052 ib->rex, si->ob->wex,
1053 ib->flags, si->ob->flags,
1054 ib->l, si->ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001055
1056 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
1057 return;
1058
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001059 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001060 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001061 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001062 si->flags |= SI_FL_WAIT_ROOM;
1063 EV_FD_COND_C(si->fd, DIR_RD);
1064 }
1065 else {
1066 /* (re)start reading */
1067 si->flags &= ~SI_FL_WAIT_ROOM;
1068 EV_FD_COND_S(si->fd, DIR_RD);
1069 }
1070}
1071
1072
1073/* This function is used for inter-stream-interface calls. It is called by the
1074 * producer to inform the consumer side that it may be interested in checking
1075 * for data in the buffer. Note that it intentionally does not update timeouts,
1076 * so that we can still check them later at wake-up.
1077 */
1078void stream_sock_chk_snd(struct stream_interface *si)
1079{
1080 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001081 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001082
1083 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",
1084 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001085 si->fd, fdtab[si->fd].owner,
1086 si->ib, ob,
1087 si->ib->rex, ob->wex,
1088 si->ib->flags, ob->flags,
1089 si->ib->l, ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001090
1091 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1092 return;
1093
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001094 if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1095 (fdtab[si->fd].ev & FD_POLL_OUT) || /* we'll be called anyway */
Willy Tarreaub22e55b2011-03-20 10:16:46 +01001096 ((ob->flags & BF_OUT_EMPTY) && !(si->send_proxy_ofs))) /* called with nothing to send ! */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001097 return;
1098
1099 retval = stream_sock_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001100 /* here, we have :
1101 * retval < 0 if an error was encountered during write.
1102 * retval = 0 if we can't write anymore without polling
1103 * retval = 1 if we're invited to come back when desired
1104 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001105 if (retval < 0) {
1106 /* Write error on the file descriptor. We mark the FD as STERROR so
1107 * that we don't use it anymore and we notify the task.
1108 */
1109 fdtab[si->fd].state = FD_STERROR;
1110 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001111 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001112 si->flags |= SI_FL_ERR;
1113 goto out_wakeup;
1114 }
1115
Willy Tarreauc54aef32009-07-27 20:08:06 +02001116 /* OK, so now we know that retval >= 0 means that some data might have
1117 * been sent, and that we may have to poll first. We have to do that
1118 * too if the buffer is not empty.
1119 */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001120 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001121 /* the connection is established but we can't write. Either the
1122 * buffer is empty, or we just refrain from sending because the
1123 * send_max limit was reached. Maybe we just wrote the last
1124 * chunk and need to close.
1125 */
Willy Tarreau520d95e2009-09-19 21:04:57 +02001126 if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
1127 (BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001128 (si->state == SI_ST_EST)) {
1129 stream_sock_shutw(si);
1130 goto out_wakeup;
1131 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001132
Willy Tarreau59454bf2009-09-20 11:13:40 +02001133 if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001134 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001135 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001136 }
1137 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +02001138 /* Otherwise there are remaining data to be sent in the buffer,
1139 * which means we have to poll before doing so.
1140 */
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001141 EV_FD_COND_S(si->fd, DIR_WR);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001142 si->flags &= ~SI_FL_WAIT_DATA;
1143 if (!tick_isset(ob->wex))
1144 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001145 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001146
Willy Tarreauc9619462009-03-09 22:40:57 +01001147 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1148 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001149 if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreauc9619462009-03-09 22:40:57 +01001150 ob->wex = tick_add_ifset(now_ms, ob->wto);
1151
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001152 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreauc9619462009-03-09 22:40:57 +01001153 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001154 * during writes, we refresh it. We only do this if the
1155 * interface is not configured for "independant streams",
1156 * because for some applications it's better not to do this,
1157 * for instance when continuously exchanging small amounts
1158 * of data which can full the socket buffers long before a
1159 * write timeout is detected.
Willy Tarreauc9619462009-03-09 22:40:57 +01001160 */
1161 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1162 }
1163 }
1164
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001165 /* in case of special condition (error, shutdown, end of write...), we
1166 * have to notify the task.
1167 */
1168 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001169 ((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001170 si->state != SI_ST_EST)) {
1171 out_wakeup:
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001172 if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
1173 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001174 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001175}
1176
Willy Tarreaueb472682010-05-28 18:46:57 +02001177/* This function is called on a read event from a listening socket, corresponding
1178 * to an accept. It tries to accept as many connections as possible, and for each
1179 * calls the listener's accept handler (generally the frontend's accept handler).
1180 */
1181int stream_sock_accept(int fd)
1182{
1183 struct listener *l = fdtab[fd].owner;
1184 struct proxy *p = l->frontend;
1185 int max_accept = global.tune.maxaccept;
1186 int cfd;
1187 int ret;
1188
1189 if (unlikely(l->nbconn >= l->maxconn)) {
1190 EV_FD_CLR(l->fd, DIR_RD);
1191 l->state = LI_FULL;
1192 return 0;
1193 }
1194
1195 if (p && p->fe_sps_lim) {
1196 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
1197 if (max_accept > max)
1198 max_accept = max;
1199 }
1200
1201 while ((!p || p->feconn < p->maxconn) && actconn < global.maxconn && max_accept--) {
1202 struct sockaddr_storage addr;
1203 socklen_t laddr = sizeof(addr);
1204
1205 cfd = accept(fd, (struct sockaddr *)&addr, &laddr);
1206 if (unlikely(cfd == -1)) {
1207 switch (errno) {
1208 case EAGAIN:
1209 case EINTR:
1210 case ECONNABORTED:
1211 return 0; /* nothing more to accept */
1212 case ENFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001213 if (p)
1214 send_log(p, LOG_EMERG,
1215 "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
1216 p->id, maxfd);
Willy Tarreaueb472682010-05-28 18:46:57 +02001217 return 0;
1218 case EMFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001219 if (p)
1220 send_log(p, LOG_EMERG,
1221 "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
1222 p->id, maxfd);
Willy Tarreaueb472682010-05-28 18:46:57 +02001223 return 0;
1224 case ENOBUFS:
1225 case ENOMEM:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001226 if (p)
1227 send_log(p, LOG_EMERG,
1228 "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
1229 p->id, maxfd);
Willy Tarreaueb472682010-05-28 18:46:57 +02001230 return 0;
1231 default:
1232 return 0;
1233 }
1234 }
1235
1236 if (unlikely(cfd >= global.maxsock)) {
Willy Tarreaufffe1322010-11-11 09:48:16 +01001237 send_log(p, LOG_EMERG,
1238 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
1239 p->id);
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001240 close(cfd);
1241 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001242 }
1243
Willy Tarreauaf7ad002010-08-31 15:39:26 +02001244 jobs++;
Willy Tarreau24dcaf32010-06-05 10:49:41 +02001245 actconn++;
1246 totalconn++;
1247 l->nbconn++;
1248
1249 if (l->counters) {
1250 if (l->nbconn > l->counters->conn_max)
1251 l->counters->conn_max = l->nbconn;
1252 }
1253
Willy Tarreaueb472682010-05-28 18:46:57 +02001254 ret = l->accept(l, cfd, &addr);
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001255 if (unlikely(ret <= 0)) {
1256 /* The connection was closed by session_accept(). Either
1257 * we just have to ignore it (ret == 0) or it's a critical
1258 * error due to a resource shortage, and we must stop the
1259 * listener (ret < 0).
1260 */
1261 jobs--;
1262 actconn--;
1263 l->nbconn--;
1264 if (ret == 0) /* successful termination */
1265 continue;
1266
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001267 if (p) {
Willy Tarreaue9f32db2010-09-21 21:14:29 +02001268 disable_listener(l);
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001269 p->state = PR_STIDLE;
1270 }
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001271 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001272 }
1273
Willy Tarreaueb472682010-05-28 18:46:57 +02001274 if (l->nbconn >= l->maxconn) {
1275 EV_FD_CLR(l->fd, DIR_RD);
1276 l->state = LI_FULL;
1277 }
Willy Tarreaueb472682010-05-28 18:46:57 +02001278 } /* end of while (p->feconn < p->maxconn) */
1279 return 0;
Willy Tarreaueb472682010-05-28 18:46:57 +02001280}
1281
Willy Tarreauabe8ea52010-11-11 10:56:04 +01001282
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001283/* Prepare a stream interface to be used in socket mode. */
1284void stream_sock_prepare_interface(struct stream_interface *si)
1285{
1286 si->update = stream_sock_data_finish;
1287 si->shutr = stream_sock_shutr;
1288 si->shutw = stream_sock_shutw;
1289 si->chk_rcv = stream_sock_chk_rcv;
1290 si->chk_snd = stream_sock_chk_snd;
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001291}
1292
Willy Tarreaubaaee002006-06-26 02:48:02 +02001293
1294/*
1295 * Local variables:
1296 * c-indent-level: 8
1297 * c-basic-offset: 8
1298 * End:
1299 */