blob: 00cb9e8be0c568ddb4d3842ad2e40cd128524a95 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Functions operating on SOCK_STREAM and buffers.
3 *
Willy Tarreau3eba98a2009-01-25 13:56:13 +01004 * Copyright 2000-2009 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
Willy Tarreaufb14edc2009-06-14 15:24:37 +020019#include <netinet/tcp.h>
20
Willy Tarreaubaaee002006-06-26 02:48:02 +020021#include <sys/socket.h>
22#include <sys/stat.h>
23#include <sys/types.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/client.h>
34#include <proto/fd.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010035#include <proto/pipe.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036#include <proto/stream_sock.h>
37#include <proto/task.h>
38
Willy Tarreau5bd8c372009-01-19 00:32:22 +010039#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040
Willy Tarreau6b4aad42009-01-18 21:59:13 +010041/* On recent Linux kernels, the splice() syscall may be used for faster data copy.
42 * But it's not always defined on some OS versions, and it even happens that some
43 * definitions are wrong with some glibc due to an offset bug in syscall().
44 */
45
46#if defined(CONFIG_HAP_LINUX_SPLICE)
47#include <unistd.h>
48#include <sys/syscall.h>
49
50#ifndef SPLICE_F_MOVE
51#define SPLICE_F_MOVE 0x1
52#endif
53
54#ifndef SPLICE_F_NONBLOCK
55#define SPLICE_F_NONBLOCK 0x2
56#endif
57
58#ifndef SPLICE_F_MORE
59#define SPLICE_F_MORE 0x4
60#endif
61
62#ifndef __NR_splice
63#if defined(__powerpc__) || defined(__powerpc64__)
64#define __NR_splice 283
65#elif defined(__sparc__) || defined(__sparc64__)
66#define __NR_splice 232
67#elif defined(__x86_64__)
68#define __NR_splice 275
69#elif defined(__alpha__)
70#define __NR_splice 468
71#elif defined (__i386__)
72#define __NR_splice 313
73#else
74#warning unsupported architecture, guessing __NR_splice=313 like x86...
75#define __NR_splice 313
76#endif /* $arch */
77
78_syscall6(int, splice, int, fdin, loff_t *, off_in, int, fdout, loff_t *, off_out, size_t, len, unsigned long, flags)
79
80#endif /* __NR_splice */
Willy Tarreau5bd8c372009-01-19 00:32:22 +010081
82/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
83 * because of timestamps. Use this as a hint for not looping on splice().
84 */
85#define SPLICE_FULL_HINT 16*1448
86
87/* Returns :
88 * -1 if splice is not possible or not possible anymore and we must switch to
89 * user-land copy (eg: to_forward reached)
90 * 0 when we know that polling is required to get more data (EAGAIN)
91 * 1 for all other cases (we can safely try again, or if an activity has been
92 * detected (DATA/NULL/ERR))
93 * Sets :
94 * BF_READ_NULL
95 * BF_READ_PARTIAL
96 * BF_WRITE_PARTIAL (during copy)
97 * BF_EMPTY (during copy)
98 * SI_FL_ERR
99 * SI_FL_WAIT_ROOM
100 * (SI_FL_WAIT_RECV)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100101 *
102 * This function automatically allocates a pipe from the pipe pool. It also
103 * carefully ensures to clear b->pipe whenever it leaves the pipe empty.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100104 */
105static int stream_sock_splice_in(struct buffer *b, struct stream_interface *si)
106{
107 int fd = si->fd;
108 int ret, max, total = 0;
109 int retval = 1;
110
111 if (!b->to_forward)
112 return -1;
113
114 if (!(b->flags & BF_KERN_SPLICING))
115 return -1;
116
117 if (b->l) {
118 /* We're embarrassed, there are already data pending in
119 * the buffer and we don't want to have them at two
120 * locations at a time. Let's indicate we need some
121 * place and ask the consumer to hurry.
122 */
123 si->flags |= SI_FL_WAIT_ROOM;
124 EV_FD_CLR(fd, DIR_RD);
125 b->rex = TICK_ETERNITY;
126 b->cons->chk_snd(b->cons);
127 return 1;
128 }
129
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100130 if (unlikely(b->pipe == NULL)) {
131 if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100132 b->flags &= ~BF_KERN_SPLICING;
133 return -1;
134 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100135 }
136
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100137 /* At this point, b->pipe is valid */
138
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100139 while (1) {
140 max = b->to_forward;
141 if (max <= 0) {
142 /* It looks like the buffer + the pipe already contain
143 * the maximum amount of data to be transferred. Try to
144 * send those data immediately on the other side if it
145 * is currently waiting.
146 */
147 retval = -1; /* end of forwarding */
148 break;
149 }
150
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100151 ret = splice(fd, NULL, b->pipe->prod, NULL, max,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100152 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
153
154 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100155 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100156 /* connection closed. This is only detected by
157 * recent kernels (>= 2.6.27.13).
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100158 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100159 b->flags |= BF_READ_NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100160 retval = 1; /* no need for further polling */
161 break;
162 }
163
164 if (errno == EAGAIN) {
165 /* there are two reasons for EAGAIN :
166 * - nothing in the socket buffer (standard)
167 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100168 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100169 * Since we don't know if pipe is full, we'll
170 * stop if the pipe is not empty. Anyway, we
171 * will almost always fill/empty the pipe.
172 */
173
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100174 if (b->pipe->data) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100175 si->flags |= SI_FL_WAIT_ROOM;
176 retval = 1;
177 break;
178 }
179
Willy Tarreau98b306b2009-01-25 11:11:32 +0100180 /* We don't know if the connection was closed.
181 * But if we're called upon POLLIN with an empty
182 * pipe and get EAGAIN, it is suspect enought to
183 * try to fall back to the normal recv scheme
184 * which will be able to deal with the situation.
185 */
186 retval = -1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100187 break;
188 }
Willy Tarreaudc340a92009-06-28 23:10:19 +0200189
190 if (errno == ENOSYS) {
191 /* splice not supported on this end, disable it */
192 b->flags &= ~BF_KERN_SPLICING;
193 si->flags &= ~SI_FL_CAP_SPLICE;
194 put_pipe(b->pipe);
195 b->pipe = NULL;
196 return -1;
197 }
198
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100199 /* here we have another error */
200 si->flags |= SI_FL_ERR;
201 retval = 1;
202 break;
203 } /* ret <= 0 */
204
205 b->to_forward -= ret;
206 total += ret;
207 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100208 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100209 b->flags |= BF_READ_PARTIAL;
210 b->flags &= ~BF_EMPTY; /* to prevent shutdowns */
211
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100212 if (b->pipe->data >= SPLICE_FULL_HINT ||
213 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100214 /* We've read enough of it for this time. */
215 retval = 1;
216 break;
217 }
218 } /* while */
219
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100220 if (unlikely(!b->pipe->data)) {
221 put_pipe(b->pipe);
222 b->pipe = NULL;
223 }
224
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100225 return retval;
226}
227
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100228#endif /* CONFIG_HAP_LINUX_SPLICE */
229
230
Willy Tarreaubaaee002006-06-26 02:48:02 +0200231/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200232 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200233 * It returns 0 if we have a high confidence that we will not be
234 * able to read more data without polling first. Returns non-zero
235 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200236 */
Willy Tarreaud7971282006-07-29 18:36:34 +0200237int stream_sock_read(int fd) {
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200238 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200239 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200240 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100241 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200242
243#ifdef DEBUG_FULL
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100244 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 +0200245#endif
246
Willy Tarreau83749182007-04-15 20:56:27 +0200247 retval = 1;
248
Willy Tarreau71543652009-07-14 19:55:05 +0200249 /* stop immediately on errors. Note that we DON'T want to stop on
250 * POLL_ERR, as the poller might report a write error while there
251 * are still data available in the recv buffer. This typically
252 * happens when we send too large a request to a backend server
253 * which rejects it before reading it all.
254 */
255 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200256 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100257
258 /* stop here if we reached the end of data */
259 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
260 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200261
Willy Tarreaud06e7112009-03-29 10:18:41 +0200262 /* maybe we were called immediately after an asynchronous shutr */
263 if (b->flags & BF_SHUTR)
264 goto out_wakeup;
265
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100266#if defined(CONFIG_HAP_LINUX_SPLICE)
267 if (b->to_forward && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100268
269 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
270 * Since older splice() implementations were buggy and returned
271 * EAGAIN on end of read, let's bypass the call to splice() now.
272 */
273 if (fdtab[fd].ev & FD_POLL_HUP)
274 goto out_shutdown_r;
275
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100276 retval = stream_sock_splice_in(b, si);
277
278 if (retval >= 0) {
279 if (si->flags & SI_FL_ERR)
280 goto out_error;
281 if (b->flags & BF_READ_NULL)
282 goto out_shutdown_r;
283 goto out_wakeup;
284 }
285 /* splice not possible (anymore), let's go on on standard copy */
286 }
287#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200288 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200289 while (1) {
290 /*
291 * 1. compute the maximum block size we can read at once.
292 */
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100293 if (b->l == 0) {
294 /* let's realign the buffer to optimize I/O */
295 b->r = b->w = b->lr = b->data;
296 max = b->max_len;
Willy Tarreau83749182007-04-15 20:56:27 +0200297 }
298 else if (b->r > b->w) {
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100299 max = b->data + b->max_len - b->r;
Willy Tarreau83749182007-04-15 20:56:27 +0200300 }
301 else {
302 max = b->w - b->r;
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100303 if (max > b->max_len)
304 max = b->max_len;
Willy Tarreau83749182007-04-15 20:56:27 +0200305 }
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100306
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100307 if (max == 0) {
308 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100309 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100310 break;
311 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200312
Willy Tarreau6996e152007-04-30 14:37:43 +0200313 /*
314 * 2. read the largest possible block
315 */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200316#ifndef MSG_NOSIGNAL
Willy Tarreau83749182007-04-15 20:56:27 +0200317 {
318 int skerr;
319 socklen_t lskerr = sizeof(skerr);
320
321 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
322 if (ret == -1 || skerr)
323 ret = -1;
324 else
325 ret = recv(fd, b->r, max, 0);
326 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200327#else
Willy Tarreau83749182007-04-15 20:56:27 +0200328 ret = recv(fd, b->r, max, MSG_NOSIGNAL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200329#endif
Willy Tarreau83749182007-04-15 20:56:27 +0200330 if (ret > 0) {
331 b->r += ret;
332 b->l += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200333 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100334
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100335 /* if we're allowed to directly forward data, we must update send_max */
336 if (b->to_forward > 0) {
337 int fwd = MIN(b->to_forward, ret);
338 b->send_max += fwd;
339 b->to_forward -= fwd;
340 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100341
Willy Tarreaub38903c2008-11-23 21:33:29 +0100342 if (fdtab[fd].state == FD_STCONN)
343 fdtab[fd].state = FD_STREADY;
344
Willy Tarreau3da77c52008-08-29 09:58:42 +0200345 b->flags |= BF_READ_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200346 b->flags &= ~BF_EMPTY;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100347
Willy Tarreau83749182007-04-15 20:56:27 +0200348 if (b->r == b->data + BUFSIZE) {
349 b->r = b->data; /* wrap around the buffer */
350 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100351
Willy Tarreau83749182007-04-15 20:56:27 +0200352 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100353
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100354 if (b->l >= b->max_len) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200355 /* The buffer is now full, there's no point in going through
356 * the loop again.
357 */
Willy Tarreau8a7af602008-05-03 23:07:14 +0200358 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) {
359 b->xfer_small = 0;
360 b->xfer_large++;
361 if (b->xfer_large >= 3) {
362 /* we call this buffer a fast streamer if it manages
363 * to be filled in one call 3 consecutive times.
364 */
365 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
366 //fputc('+', stderr);
367 }
368 }
369 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
370 (cur_read <= BUFSIZE / 2)) {
371 b->xfer_large = 0;
372 b->xfer_small++;
373 if (b->xfer_small >= 2) {
374 /* if the buffer has been at least half full twice,
375 * we receive faster than we send, so at least it
376 * is not a "fast streamer".
377 */
378 b->flags &= ~BF_STREAMER_FAST;
379 //fputc('-', stderr);
380 }
381 }
382 else {
383 b->xfer_small = 0;
384 b->xfer_large = 0;
385 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100386
387 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100388 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100389 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200390 }
391
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200392 /* if too many bytes were missing from last read, it means that
393 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100394 * not have them in buffers. BTW, if FD_POLL_HUP was present,
395 * it means that we have reached the end and that the connection
396 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200397 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100398 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200399 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
400 (cur_read <= BUFSIZE / 2)) {
401 b->xfer_large = 0;
402 b->xfer_small++;
403 if (b->xfer_small >= 3) {
404 /* we have read less than half of the buffer in
405 * one pass, and this happened at least 3 times.
406 * This is definitely not a streamer.
407 */
408 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
409 //fputc('!', stderr);
410 }
411 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200412 /* unfortunately, on level-triggered events, POLL_HUP
413 * is generally delivered AFTER the system buffer is
414 * empty, so this one might never match.
415 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100416 if (fdtab[fd].ev & FD_POLL_HUP)
417 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200418
419 /* if a streamer has read few data, it may be because we
420 * have exhausted system buffers. It's not worth trying
421 * again.
422 */
423 if (b->flags & BF_STREAMER)
424 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200425
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100426 /* generally if we read something smaller than 1 or 2 MSS,
427 * it means that either we have exhausted the system's
428 * buffers (streamer or question-response protocol) or
429 * that the connection will be closed. Streamers are
430 * easily detected so we return early. For other cases,
431 * it's still better to perform a last read to be sure,
432 * because it may save one complete poll/read/wakeup cycle
433 * in case of shutdown.
434 */
435 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
436 break;
437
438 /* if we read a large block smaller than what we requested,
439 * it's almost certain we'll never get anything more.
440 */
441 if (ret >= global.tune.recv_enough)
442 break;
443 }
Willy Tarreau83749182007-04-15 20:56:27 +0200444
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100445 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200446 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200447 }
448 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200449 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100450 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200451 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200452 else if (errno == EAGAIN) {
453 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100454 * nothing to read left if we did not read much, ie
455 * less than what we were still expecting to read.
456 * But we may have done some work justifying to notify
457 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200458 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100459 if (cur_read < MIN_RET_FOR_READ_LOOP)
460 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200461 break;
462 }
463 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200464 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200465 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200466 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200467
Willy Tarreau6996e152007-04-30 14:37:43 +0200468 out_wakeup:
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100469 /* We might have some data the consumer is waiting for */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100470 if ((b->send_max || b->pipe) && (b->cons->flags & SI_FL_WAIT_DATA)) {
471 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100472
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100473 b->cons->chk_snd(b->cons);
474
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100475 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100476 if (!(b->flags & BF_FULL) &&
477 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100478 si->flags &= ~SI_FL_WAIT_ROOM;
479 }
480
481 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100482 EV_FD_CLR(fd, DIR_RD);
483 b->rex = TICK_ETERNITY;
484 }
Willy Tarreaud06e7112009-03-29 10:18:41 +0200485 else if ((b->flags & (BF_SHUTR|BF_READ_PARTIAL|BF_FULL|BF_READ_NOEXP)) == BF_READ_PARTIAL)
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100486 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100487
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100488 /* we have to wake up if there is a special event or if we don't have
489 * any more data to forward.
490 */
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100491 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR|BF_SHUTR|BF_READ_DONTWAIT)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100492 !b->to_forward ||
493 si->state != SI_ST_EST ||
494 b->cons->state != SI_ST_EST ||
495 (si->flags & SI_FL_ERR))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100496 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100497
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100498 b->flags &= ~BF_READ_DONTWAIT;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100499 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200500 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200501
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100502 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200503 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100504 fdtab[fd].ev &= ~FD_POLL_HUP;
505 b->flags |= BF_READ_NULL;
Willy Tarreau99126c32008-11-27 10:30:51 +0100506 stream_sock_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200507 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100508
Willy Tarreau6996e152007-04-30 14:37:43 +0200509 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100510 /* Read error on the file descriptor. We mark the FD as STERROR so
511 * that we don't use it anymore. The error is reported to the stream
512 * interface which will take proper action. We must not perturbate the
513 * buffer because the stream interface wants to ensure transparent
514 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200515 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100516
Willy Tarreau6996e152007-04-30 14:37:43 +0200517 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100518 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100519 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100520 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100521 retval = 1;
522 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200523}
524
525
526/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100527 * This function is called to send buffer data to a stream socket.
528 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100529 * before calling it again, otherwise 1. If a pipe was associated with the
530 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200531 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100532static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100533{
Willy Tarreau83749182007-04-15 20:56:27 +0200534 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100535 int retval = 1;
536 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200537
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100538#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100539 while (b->pipe) {
540 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100541 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
542 if (ret <= 0) {
543 if (ret == 0 || errno == EAGAIN) {
544 retval = 0;
545 return retval;
546 }
547 /* here we have another error */
548 retval = -1;
549 return retval;
550 }
551
552 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100553 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100554
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100555 if (!b->pipe->data) {
556 put_pipe(b->pipe);
557 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100558 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100559 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100560
561 if (--write_poll <= 0)
562 return retval;
563 }
564
565 /* At this point, the pipe is empty, but we may still have data pending
566 * in the normal buffer.
567 */
568 if (!b->l) {
569 b->flags |= BF_EMPTY;
570 return retval;
571 }
572#endif
Willy Tarreaud2def0f2009-01-18 17:37:33 +0100573 if (!b->send_max)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100574 return retval;
Willy Tarreau83749182007-04-15 20:56:27 +0200575
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100576 /* when we're in this loop, we already know that there is no spliced
577 * data left, and that there are sendable buffered data.
578 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200579 while (1) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100580 if (b->r > b->w)
Willy Tarreau83749182007-04-15 20:56:27 +0200581 max = b->r - b->w;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100582 else
Willy Tarreau83749182007-04-15 20:56:27 +0200583 max = b->data + BUFSIZE - b->w;
Willy Tarreau83749182007-04-15 20:56:27 +0200584
Willy Tarreauf890dc92008-12-13 21:12:26 +0100585 /* limit the amount of outgoing data if required */
586 if (max > b->send_max)
587 max = b->send_max;
588
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200589
590#ifdef TCP_CORK
591 /*
592 * Check if we want to cork output before sending. This typically occurs
593 * when there are data left in the buffer, or when we reached the end of
594 * buffer but we know we will close, so we try to merge the ongoing FIN
595 * with the last data segment.
596 */
Willy Tarreau5d707e12009-06-28 11:09:07 +0200597 if ((fdtab[si->fd].flags & (FD_FL_TCP|FD_FL_TCP_NOLING|FD_FL_TCP_CORK)) == FD_FL_TCP) {
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200598 if (unlikely((b->send_max == b->l &&
599 (b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
600 (BF_WRITE_ENA|BF_SHUTR)))) {
601 /* we have to unconditionally reset TCP_NODELAY for CORK */
602 setsockopt(si->fd, IPPROTO_TCP, TCP_NODELAY, (char *) &zero, sizeof(zero));
603 setsockopt(si->fd, SOL_TCP, TCP_CORK, (char *) &one, sizeof(one));
604 fdtab[si->fd].flags = (fdtab[si->fd].flags & ~FD_FL_TCP_NODELAY) | FD_FL_TCP_CORK;
605 }
606 }
607#endif
608
Willy Tarreaubaaee002006-06-26 02:48:02 +0200609#ifndef MSG_NOSIGNAL
610 {
611 int skerr;
612 socklen_t lskerr = sizeof(skerr);
613
Willy Tarreau87bed622009-03-08 22:25:28 +0100614 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200615 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200616 ret = -1;
617 else
Willy Tarreau87bed622009-03-08 22:25:28 +0100618 ret = send(si->fd, b->w, max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200619 }
620#else
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100621 ret = send(si->fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200622#endif
623
624 if (ret > 0) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100625 if (fdtab[si->fd].state == FD_STCONN)
626 fdtab[si->fd].state = FD_STREADY;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100627
Willy Tarreau3da77c52008-08-29 09:58:42 +0200628 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200629
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100630 b->w += ret;
631 if (b->w == b->data + BUFSIZE)
632 b->w = b->data; /* wrap around the buffer */
633
634 b->l -= ret;
635 if (likely(b->l < b->max_len))
Willy Tarreaue393fe22008-08-16 22:18:07 +0200636 b->flags &= ~BF_FULL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100637
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100638 if (likely(!b->l)) {
639 /* optimize data alignment in the buffer */
640 b->r = b->w = b->lr = b->data;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100641 if (likely(!b->pipe))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100642 b->flags |= BF_EMPTY;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200643 }
Willy Tarreau83749182007-04-15 20:56:27 +0200644
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100645 b->send_max -= ret;
646 if (!b->send_max || !b->l)
647 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200648
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200649 /* if the system buffer is full, don't insist */
650 if (ret < max)
651 break;
652
Willy Tarreau6996e152007-04-30 14:37:43 +0200653 if (--write_poll <= 0)
654 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200655 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200656 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100657 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200658 retval = 0;
659 break;
660 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200661 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100662 /* bad, we got an error */
663 retval = -1;
664 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200665 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200666 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200667
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200668 /* check if we need to uncork the output, for instance when the
669 * output buffer is empty but not shutr().
670 */
671 if (unlikely((fdtab[si->fd].flags & (FD_FL_TCP|FD_FL_TCP_NODELAY)) == FD_FL_TCP && (b->flags & BF_EMPTY))) {
672 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) != (BF_WRITE_ENA|BF_SHUTR)) {
673#ifdef TCP_CORK
674 if (fdtab[si->fd].flags & FD_FL_TCP_CORK)
675 setsockopt(si->fd, SOL_TCP, TCP_CORK, (char *) &zero, sizeof(zero));
676#endif
677 setsockopt(si->fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
678 fdtab[si->fd].flags = (fdtab[si->fd].flags & ~FD_FL_TCP_CORK) | FD_FL_TCP_NODELAY;
679 }
680 }
681
682
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100683 return retval;
684}
Willy Tarreau6996e152007-04-30 14:37:43 +0200685
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100686
687/*
688 * This function is called on a write event from a stream socket.
689 * It returns 0 if the caller needs to poll before calling it again, otherwise
690 * non-zero.
691 */
692int stream_sock_write(int fd)
693{
694 struct stream_interface *si = fdtab[fd].owner;
695 struct buffer *b = si->ob;
696 int retval = 1;
697
698#ifdef DEBUG_FULL
699 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
700#endif
701
702 retval = 1;
Willy Tarreau71543652009-07-14 19:55:05 +0200703 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100704 goto out_error;
705
Willy Tarreaud06e7112009-03-29 10:18:41 +0200706 /* we might have been called just after an asynchronous shutw */
707 if (b->flags & BF_SHUTW)
708 goto out_wakeup;
709
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100710 if (likely(!(b->flags & BF_EMPTY))) {
711 /* OK there are data waiting to be sent */
712 retval = stream_sock_write_loop(si, b);
713 if (retval < 0)
714 goto out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200715 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100716 else {
717 /* may be we have received a connection acknowledgement in TCP mode without data */
718 if (likely(fdtab[fd].state == FD_STCONN)) {
719 /* We have no data to send to check the connection, and
720 * getsockopt() will not inform us whether the connection
721 * is still pending. So we'll reuse connect() to check the
722 * state of the socket. This has the advantage of givig us
723 * the following info :
724 * - error
725 * - connecting (EALREADY, EINPROGRESS)
726 * - connected (EISCONN, 0)
727 */
728 if ((connect(fd, fdtab[fd].peeraddr, fdtab[fd].peerlen) == 0))
729 errno = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200730
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100731 if (errno == EALREADY || errno == EINPROGRESS) {
732 retval = 0;
733 goto out_may_wakeup;
734 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100735
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100736 if (errno && errno != EISCONN)
737 goto out_error;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200738
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100739 /* OK we just need to indicate that we got a connection
740 * and that we wrote nothing.
741 */
742 b->flags |= BF_WRITE_NULL;
743 fdtab[fd].state = FD_STREADY;
744 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200745
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100746 /* Funny, we were called to write something but there wasn't
747 * anything. We can get there, for example if we were woken up
748 * on a write event to finish the splice, but the send_max is 0
749 * so we cannot write anything from the buffer. Let's disable
750 * the write event and pretend we never came there.
751 */
752 }
753
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100754 if (!b->pipe && !b->send_max) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100755 /* the connection is established but we can't write. Either the
756 * buffer is empty, or we just refrain from sending because the
757 * send_max limit was reached. Maybe we just wrote the last
758 * chunk and need to close.
759 */
760 if (((b->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
761 (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) &&
762 (si->state == SI_ST_EST)) {
763 stream_sock_shutw(si);
764 goto out_wakeup;
765 }
766
Willy Tarreaud06e7112009-03-29 10:18:41 +0200767 if ((b->flags & (BF_EMPTY|BF_SHUTW)) == BF_EMPTY)
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 Tarreau3eba98a2009-01-25 13:56:13 +0100777 if ((b->send_max || b->pipe) &&
Willy Tarreaud2def0f2009-01-18 17:37:33 +0100778 (b->flags & (BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100779 b->wex = tick_add_ifset(now_ms, b->wto);
780
781 out_wakeup:
782 if (tick_isset(si->ib->rex)) {
783 /* Note: to prevent the client from expiring read timeouts
784 * during writes, we refresh it. A better solution would be
785 * to merge read+write timeouts into a unique one, although
786 * that needs some study particularly on full-duplex TCP
787 * connections.
788 */
789 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
790 }
791
792 /* the producer might be waiting for more room to store data */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200793 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100794 (b->prod->flags & SI_FL_WAIT_ROOM)))
795 b->prod->chk_rcv(b->prod);
796
797 /* we have to wake up if there is a special event or if we don't have
798 * any more data to forward and it's not planned to send any more.
799 */
800 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100801 (!b->to_forward && !b->send_max && !b->pipe) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100802 si->state != SI_ST_EST ||
803 b->prod->state != SI_ST_EST))
804 task_wakeup(si->owner, TASK_WOKEN_IO);
805 }
806
807 fdtab[fd].ev &= ~FD_POLL_OUT;
808 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100809
Willy Tarreau6996e152007-04-30 14:37:43 +0200810 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100811 /* Write error on the file descriptor. We mark the FD as STERROR so
812 * that we don't use it anymore. The error is reported to the stream
813 * interface which will take proper action. We must not perturbate the
814 * buffer because the stream interface wants to ensure transparent
815 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200816 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100817
Willy Tarreau6996e152007-04-30 14:37:43 +0200818 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100819 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100820 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100821 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200822 task_wakeup(si->owner, TASK_WOKEN_IO);
823 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200824}
825
Willy Tarreau48adac52008-08-30 04:58:38 +0200826/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200827 * This function performs a shutdown-write on a stream interface in a connected or
828 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100829 * or closes the file descriptor and marks itself as closed. The buffer flags are
830 * updated to reflect the new state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200831 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100832void stream_sock_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200833{
Willy Tarreau99126c32008-11-27 10:30:51 +0100834 if (si->ob->flags & BF_SHUTW)
835 return;
836 si->ob->flags |= BF_SHUTW;
837 si->ob->wex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100838 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau99126c32008-11-27 10:30:51 +0100839
Willy Tarreaub38903c2008-11-23 21:33:29 +0100840 switch (si->state) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100841 case SI_ST_EST:
Willy Tarreau720058c2009-07-14 19:21:50 +0200842 /* we have to shut before closing, otherwise some short messages
843 * may never leave the system, especially when there are remaining
844 * unread data in the socket input buffer, or when nolinger is set.
845 */
846 EV_FD_CLR(si->fd, DIR_WR);
847 shutdown(si->fd, SHUT_WR);
848
849 if (!(si->ib->flags & BF_SHUTR))
Willy Tarreaub38903c2008-11-23 21:33:29 +0100850 return;
Willy Tarreau5d707e12009-06-28 11:09:07 +0200851
Willy Tarreaub38903c2008-11-23 21:33:29 +0100852 /* fall through */
853 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100854 /* we may have to close a pending connection, and mark the
855 * response buffer as shutr
856 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200857 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100858 /* fall through */
859 case SI_ST_CER:
Willy Tarreau7f006512008-12-07 14:04:04 +0100860 si->state = SI_ST_DIS;
861 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200862 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100863 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100864 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100865 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100866 return;
Willy Tarreau48adac52008-08-30 04:58:38 +0200867 }
Willy Tarreau48adac52008-08-30 04:58:38 +0200868}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200869
Willy Tarreau2d212792008-08-27 21:41:35 +0200870/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200871 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100872 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100873 * or closes the file descriptor and marks itself as closed. The buffer flags are
874 * updated to reflect the new state.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200875 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100876void stream_sock_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200877{
Willy Tarreau99126c32008-11-27 10:30:51 +0100878 if (si->ib->flags & BF_SHUTR)
879 return;
880 si->ib->flags |= BF_SHUTR;
881 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100882 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100883
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100884 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100885 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200886
Willy Tarreaucff64112008-11-03 06:26:53 +0100887 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200888 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100889 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100890 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100891 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200892 }
893 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100894 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200895}
896
897/*
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200898 * Updates a connected stream_sock file descriptor status and timeouts
899 * according to the buffers' flags. It should only be called once after the
900 * buffer flags have settled down, and before they are cleared. It doesn't
901 * harm to call it as often as desired (it just slightly hurts performance).
902 */
Willy Tarreaub0253252008-11-30 21:37:12 +0100903void stream_sock_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200904{
Willy Tarreaub0253252008-11-30 21:37:12 +0100905 struct buffer *ib = si->ib;
906 struct buffer *ob = si->ob;
907 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200908
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200909 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 +0200910 now_ms, __FUNCTION__,
911 fd, fdtab[fd].owner,
912 ib, ob,
913 ib->rex, ob->wex,
914 ib->flags, ob->flags,
Willy Tarreaub0253252008-11-30 21:37:12 +0100915 ib->l, ob->l, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200916
917 /* Check if we need to close the read side */
918 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200919 /* Read not closed, update FD status and timeout for reads */
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200920 if (ib->flags & (BF_FULL|BF_HIJACK)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200921 /* stop reading */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100922 if ((ib->flags & (BF_FULL|BF_HIJACK)) == BF_FULL)
923 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200924 EV_FD_COND_C(fd, DIR_RD);
925 ib->rex = TICK_ETERNITY;
926 }
927 else {
928 /* (re)start reading and update timeout. Note: we don't recompute the timeout
929 * everytime we get here, otherwise it would risk never to expire. We only
930 * update it if is was not yet set, or if we already got some read status.
931 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100932 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200933 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreau86491c32008-12-14 09:04:47 +0100934 if (!(ib->flags & BF_READ_NOEXP) &&
935 (!tick_isset(ib->rex) || ib->flags & BF_READ_ACTIVITY))
Willy Tarreau2d212792008-08-27 21:41:35 +0200936 ib->rex = tick_add_ifset(now_ms, ib->rto);
937 }
938 }
939
940 /* Check if we need to close the write side */
941 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200942 /* Write not closed, update FD status and timeout for writes */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100943 if ((ob->send_max == 0 && !ob->pipe) ||
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100944 (ob->flags & BF_EMPTY) ||
Willy Tarreau3da77c52008-08-29 09:58:42 +0200945 (ob->flags & (BF_HIJACK|BF_WRITE_ENA)) == 0) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200946 /* stop writing */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100947 if ((ob->flags & (BF_EMPTY|BF_HIJACK|BF_WRITE_ENA)) == (BF_EMPTY|BF_WRITE_ENA))
948 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200949 EV_FD_COND_C(fd, DIR_WR);
950 ob->wex = TICK_ETERNITY;
951 }
952 else {
953 /* (re)start writing and update timeout. Note: we don't recompute the timeout
954 * everytime we get here, otherwise it would risk never to expire. We only
955 * update it if is was not yet set, or if we already got some write status.
956 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100957 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200958 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200959 if (!tick_isset(ob->wex) || ob->flags & BF_WRITE_ACTIVITY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200960 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreaud06e7112009-03-29 10:18:41 +0200961 if (tick_isset(ib->rex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200962 /* Note: depending on the protocol, we don't know if we're waiting
963 * for incoming data or not. So in order to prevent the socket from
964 * expiring read timeouts during writes, we refresh the read timeout,
965 * except if it was already infinite.
966 */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200967 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +0200968 }
969 }
970 }
971 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200972}
973
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100974/* This function is used for inter-stream-interface calls. It is called by the
975 * consumer to inform the producer side that it may be interested in checking
976 * for free space in the buffer. Note that it intentionally does not update
977 * timeouts, so that we can still check them later at wake-up.
978 */
979void stream_sock_chk_rcv(struct stream_interface *si)
980{
981 struct buffer *ib = si->ib;
982
983 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",
984 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +0000985 si->fd, fdtab[si->fd].owner,
986 ib, si->ob,
987 ib->rex, si->ob->wex,
988 ib->flags, si->ob->flags,
989 ib->l, si->ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100990
991 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
992 return;
993
994 if (ib->flags & (BF_FULL|BF_HIJACK)) {
995 /* stop reading */
996 if ((ib->flags & (BF_FULL|BF_HIJACK)) == BF_FULL)
997 si->flags |= SI_FL_WAIT_ROOM;
998 EV_FD_COND_C(si->fd, DIR_RD);
999 }
1000 else {
1001 /* (re)start reading */
1002 si->flags &= ~SI_FL_WAIT_ROOM;
1003 EV_FD_COND_S(si->fd, DIR_RD);
1004 }
1005}
1006
1007
1008/* This function is used for inter-stream-interface calls. It is called by the
1009 * producer to inform the consumer side that it may be interested in checking
1010 * for data in the buffer. Note that it intentionally does not update timeouts,
1011 * so that we can still check them later at wake-up.
1012 */
1013void stream_sock_chk_snd(struct stream_interface *si)
1014{
1015 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001016 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001017
1018 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",
1019 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001020 si->fd, fdtab[si->fd].owner,
1021 si->ib, ob,
1022 si->ib->rex, ob->wex,
1023 si->ib->flags, ob->flags,
1024 si->ib->l, ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001025
1026 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1027 return;
1028
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001029 if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1030 (fdtab[si->fd].ev & FD_POLL_OUT) || /* we'll be called anyway */
Willy Tarreau3eba98a2009-01-25 13:56:13 +01001031 !(ob->send_max || ob->pipe) || /* called with nothing to send ! */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001032 !(ob->flags & (BF_HIJACK|BF_WRITE_ENA))) /* we may not write */
1033 return;
1034
1035 retval = stream_sock_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001036 /* here, we have :
1037 * retval < 0 if an error was encountered during write.
1038 * retval = 0 if we can't write anymore without polling
1039 * retval = 1 if we're invited to come back when desired
1040 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001041 if (retval < 0) {
1042 /* Write error on the file descriptor. We mark the FD as STERROR so
1043 * that we don't use it anymore and we notify the task.
1044 */
1045 fdtab[si->fd].state = FD_STERROR;
1046 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001047 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001048 si->flags |= SI_FL_ERR;
1049 goto out_wakeup;
1050 }
1051
Willy Tarreauc54aef32009-07-27 20:08:06 +02001052 /* OK, so now we know that retval >= 0 means that some data might have
1053 * been sent, and that we may have to poll first. We have to do that
1054 * too if the buffer is not empty.
1055 */
1056 if (ob->send_max == 0 && !ob->pipe) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001057 /* the connection is established but we can't write. Either the
1058 * buffer is empty, or we just refrain from sending because the
1059 * send_max limit was reached. Maybe we just wrote the last
1060 * chunk and need to close.
1061 */
1062 if (((ob->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
1063 (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) &&
1064 (si->state == SI_ST_EST)) {
1065 stream_sock_shutw(si);
1066 goto out_wakeup;
1067 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001068
1069 if ((ob->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA)) == (BF_EMPTY|BF_WRITE_ENA))
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001070 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001071 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001072 }
1073 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +02001074 /* Otherwise there are remaining data to be sent in the buffer,
1075 * which means we have to poll before doing so.
1076 */
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001077 EV_FD_COND_S(si->fd, DIR_WR);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001078 si->flags &= ~SI_FL_WAIT_DATA;
1079 if (!tick_isset(ob->wex))
1080 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001081 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001082
Willy Tarreauc9619462009-03-09 22:40:57 +01001083 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1084 /* update timeout if we have written something */
1085 if ((ob->send_max || ob->pipe) &&
1086 (ob->flags & (BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
1087 ob->wex = tick_add_ifset(now_ms, ob->wto);
1088
1089 if (tick_isset(si->ib->rex)) {
1090 /* Note: to prevent the client from expiring read timeouts
1091 * during writes, we refresh it. A better solution would be
1092 * to merge read+write timeouts into a unique one, although
1093 * that needs some study particularly on full-duplex TCP
1094 * connections.
1095 */
1096 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1097 }
1098 }
1099
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001100 /* in case of special condition (error, shutdown, end of write...), we
1101 * have to notify the task.
1102 */
1103 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreau3eba98a2009-01-25 13:56:13 +01001104 (!ob->to_forward && !ob->send_max && !ob->pipe) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001105 si->state != SI_ST_EST)) {
1106 out_wakeup:
1107 task_wakeup(si->owner, TASK_WOKEN_IO);
1108 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001109}
1110
Willy Tarreaubaaee002006-06-26 02:48:02 +02001111
1112/*
1113 * Local variables:
1114 * c-indent-level: 8
1115 * c-basic-offset: 8
1116 * End:
1117 */