blob: a3ef26992617932788656c5a9c1b8446fb475fcd [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 Tarreau5bd8c372009-01-19 00:32:22 +0100189 /* here we have another error */
190 si->flags |= SI_FL_ERR;
191 retval = 1;
192 break;
193 } /* ret <= 0 */
194
195 b->to_forward -= ret;
196 total += ret;
197 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100198 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100199 b->flags |= BF_READ_PARTIAL;
200 b->flags &= ~BF_EMPTY; /* to prevent shutdowns */
201
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100202 if (b->pipe->data >= SPLICE_FULL_HINT ||
203 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100204 /* We've read enough of it for this time. */
205 retval = 1;
206 break;
207 }
208 } /* while */
209
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100210 if (unlikely(!b->pipe->data)) {
211 put_pipe(b->pipe);
212 b->pipe = NULL;
213 }
214
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100215 return retval;
216}
217
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100218#endif /* CONFIG_HAP_LINUX_SPLICE */
219
220
Willy Tarreaubaaee002006-06-26 02:48:02 +0200221/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200222 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200223 * It returns 0 if we have a high confidence that we will not be
224 * able to read more data without polling first. Returns non-zero
225 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200226 */
Willy Tarreaud7971282006-07-29 18:36:34 +0200227int stream_sock_read(int fd) {
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200228 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200229 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200230 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100231 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200232
233#ifdef DEBUG_FULL
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100234 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 +0200235#endif
236
Willy Tarreau83749182007-04-15 20:56:27 +0200237 retval = 1;
238
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100239 /* stop immediately on errors */
240 if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR))
Willy Tarreau6996e152007-04-30 14:37:43 +0200241 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100242
243 /* stop here if we reached the end of data */
244 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
245 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200246
Willy Tarreaud06e7112009-03-29 10:18:41 +0200247 /* maybe we were called immediately after an asynchronous shutr */
248 if (b->flags & BF_SHUTR)
249 goto out_wakeup;
250
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100251#if defined(CONFIG_HAP_LINUX_SPLICE)
252 if (b->to_forward && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100253
254 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
255 * Since older splice() implementations were buggy and returned
256 * EAGAIN on end of read, let's bypass the call to splice() now.
257 */
258 if (fdtab[fd].ev & FD_POLL_HUP)
259 goto out_shutdown_r;
260
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100261 retval = stream_sock_splice_in(b, si);
262
263 if (retval >= 0) {
264 if (si->flags & SI_FL_ERR)
265 goto out_error;
266 if (b->flags & BF_READ_NULL)
267 goto out_shutdown_r;
268 goto out_wakeup;
269 }
270 /* splice not possible (anymore), let's go on on standard copy */
271 }
272#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200273 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200274 while (1) {
275 /*
276 * 1. compute the maximum block size we can read at once.
277 */
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100278 if (b->l == 0) {
279 /* let's realign the buffer to optimize I/O */
280 b->r = b->w = b->lr = b->data;
281 max = b->max_len;
Willy Tarreau83749182007-04-15 20:56:27 +0200282 }
283 else if (b->r > b->w) {
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100284 max = b->data + b->max_len - b->r;
Willy Tarreau83749182007-04-15 20:56:27 +0200285 }
286 else {
287 max = b->w - b->r;
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100288 if (max > b->max_len)
289 max = b->max_len;
Willy Tarreau83749182007-04-15 20:56:27 +0200290 }
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100291
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100292 if (max == 0) {
293 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100294 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100295 break;
296 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200297
Willy Tarreau6996e152007-04-30 14:37:43 +0200298 /*
299 * 2. read the largest possible block
300 */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200301#ifndef MSG_NOSIGNAL
Willy Tarreau83749182007-04-15 20:56:27 +0200302 {
303 int skerr;
304 socklen_t lskerr = sizeof(skerr);
305
306 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
307 if (ret == -1 || skerr)
308 ret = -1;
309 else
310 ret = recv(fd, b->r, max, 0);
311 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200312#else
Willy Tarreau83749182007-04-15 20:56:27 +0200313 ret = recv(fd, b->r, max, MSG_NOSIGNAL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200314#endif
Willy Tarreau83749182007-04-15 20:56:27 +0200315 if (ret > 0) {
316 b->r += ret;
317 b->l += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200318 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100319
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100320 /* if we're allowed to directly forward data, we must update send_max */
321 if (b->to_forward > 0) {
322 int fwd = MIN(b->to_forward, ret);
323 b->send_max += fwd;
324 b->to_forward -= fwd;
325 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100326
Willy Tarreaub38903c2008-11-23 21:33:29 +0100327 if (fdtab[fd].state == FD_STCONN)
328 fdtab[fd].state = FD_STREADY;
329
Willy Tarreau3da77c52008-08-29 09:58:42 +0200330 b->flags |= BF_READ_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200331 b->flags &= ~BF_EMPTY;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100332
Willy Tarreau83749182007-04-15 20:56:27 +0200333 if (b->r == b->data + BUFSIZE) {
334 b->r = b->data; /* wrap around the buffer */
335 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100336
Willy Tarreau83749182007-04-15 20:56:27 +0200337 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100338
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100339 if (b->l >= b->max_len) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200340 /* The buffer is now full, there's no point in going through
341 * the loop again.
342 */
Willy Tarreau8a7af602008-05-03 23:07:14 +0200343 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) {
344 b->xfer_small = 0;
345 b->xfer_large++;
346 if (b->xfer_large >= 3) {
347 /* we call this buffer a fast streamer if it manages
348 * to be filled in one call 3 consecutive times.
349 */
350 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
351 //fputc('+', stderr);
352 }
353 }
354 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
355 (cur_read <= BUFSIZE / 2)) {
356 b->xfer_large = 0;
357 b->xfer_small++;
358 if (b->xfer_small >= 2) {
359 /* if the buffer has been at least half full twice,
360 * we receive faster than we send, so at least it
361 * is not a "fast streamer".
362 */
363 b->flags &= ~BF_STREAMER_FAST;
364 //fputc('-', stderr);
365 }
366 }
367 else {
368 b->xfer_small = 0;
369 b->xfer_large = 0;
370 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100371
372 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100373 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100374 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200375 }
376
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200377 /* if too many bytes were missing from last read, it means that
378 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100379 * not have them in buffers. BTW, if FD_POLL_HUP was present,
380 * it means that we have reached the end and that the connection
381 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200382 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100383 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200384 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
385 (cur_read <= BUFSIZE / 2)) {
386 b->xfer_large = 0;
387 b->xfer_small++;
388 if (b->xfer_small >= 3) {
389 /* we have read less than half of the buffer in
390 * one pass, and this happened at least 3 times.
391 * This is definitely not a streamer.
392 */
393 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
394 //fputc('!', stderr);
395 }
396 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200397 /* unfortunately, on level-triggered events, POLL_HUP
398 * is generally delivered AFTER the system buffer is
399 * empty, so this one might never match.
400 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100401 if (fdtab[fd].ev & FD_POLL_HUP)
402 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200403
404 /* if a streamer has read few data, it may be because we
405 * have exhausted system buffers. It's not worth trying
406 * again.
407 */
408 if (b->flags & BF_STREAMER)
409 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200410
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100411 /* generally if we read something smaller than 1 or 2 MSS,
412 * it means that either we have exhausted the system's
413 * buffers (streamer or question-response protocol) or
414 * that the connection will be closed. Streamers are
415 * easily detected so we return early. For other cases,
416 * it's still better to perform a last read to be sure,
417 * because it may save one complete poll/read/wakeup cycle
418 * in case of shutdown.
419 */
420 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
421 break;
422
423 /* if we read a large block smaller than what we requested,
424 * it's almost certain we'll never get anything more.
425 */
426 if (ret >= global.tune.recv_enough)
427 break;
428 }
Willy Tarreau83749182007-04-15 20:56:27 +0200429
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100430 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200431 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200432 }
433 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200434 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100435 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200436 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200437 else if (errno == EAGAIN) {
438 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100439 * nothing to read left if we did not read much, ie
440 * less than what we were still expecting to read.
441 * But we may have done some work justifying to notify
442 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200443 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100444 if (cur_read < MIN_RET_FOR_READ_LOOP)
445 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200446 break;
447 }
448 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200449 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200450 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200451 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200452
Willy Tarreau6996e152007-04-30 14:37:43 +0200453 out_wakeup:
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100454 /* We might have some data the consumer is waiting for */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100455 if ((b->send_max || b->pipe) && (b->cons->flags & SI_FL_WAIT_DATA)) {
456 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100457
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100458 b->cons->chk_snd(b->cons);
459
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100460 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100461 if (!(b->flags & BF_FULL) &&
462 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100463 si->flags &= ~SI_FL_WAIT_ROOM;
464 }
465
466 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100467 EV_FD_CLR(fd, DIR_RD);
468 b->rex = TICK_ETERNITY;
469 }
Willy Tarreaud06e7112009-03-29 10:18:41 +0200470 else if ((b->flags & (BF_SHUTR|BF_READ_PARTIAL|BF_FULL|BF_READ_NOEXP)) == BF_READ_PARTIAL)
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100471 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100472
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100473 /* we have to wake up if there is a special event or if we don't have
474 * any more data to forward.
475 */
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100476 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR|BF_SHUTR|BF_READ_DONTWAIT)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100477 !b->to_forward ||
478 si->state != SI_ST_EST ||
479 b->cons->state != SI_ST_EST ||
480 (si->flags & SI_FL_ERR))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100481 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100482
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100483 b->flags &= ~BF_READ_DONTWAIT;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100484 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200485 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200486
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100487 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200488 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100489 fdtab[fd].ev &= ~FD_POLL_HUP;
490 b->flags |= BF_READ_NULL;
Willy Tarreau99126c32008-11-27 10:30:51 +0100491 stream_sock_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200492 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100493
Willy Tarreau6996e152007-04-30 14:37:43 +0200494 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100495 /* Read error on the file descriptor. We mark the FD as STERROR so
496 * that we don't use it anymore. The error is reported to the stream
497 * interface which will take proper action. We must not perturbate the
498 * buffer because the stream interface wants to ensure transparent
499 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200500 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100501
Willy Tarreau6996e152007-04-30 14:37:43 +0200502 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100503 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100504 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100505 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100506 retval = 1;
507 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200508}
509
510
511/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100512 * This function is called to send buffer data to a stream socket.
513 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100514 * before calling it again, otherwise 1. If a pipe was associated with the
515 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200516 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100517static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100518{
Willy Tarreau83749182007-04-15 20:56:27 +0200519 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100520 int retval = 1;
521 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200522
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100523#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100524 while (b->pipe) {
525 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100526 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
527 if (ret <= 0) {
528 if (ret == 0 || errno == EAGAIN) {
529 retval = 0;
530 return retval;
531 }
532 /* here we have another error */
533 retval = -1;
534 return retval;
535 }
536
537 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100538 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100539
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100540 if (!b->pipe->data) {
541 put_pipe(b->pipe);
542 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100543 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100544 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100545
546 if (--write_poll <= 0)
547 return retval;
548 }
549
550 /* At this point, the pipe is empty, but we may still have data pending
551 * in the normal buffer.
552 */
553 if (!b->l) {
554 b->flags |= BF_EMPTY;
555 return retval;
556 }
557#endif
Willy Tarreaud2def0f2009-01-18 17:37:33 +0100558 if (!b->send_max)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100559 return retval;
Willy Tarreau83749182007-04-15 20:56:27 +0200560
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100561 /* when we're in this loop, we already know that there is no spliced
562 * data left, and that there are sendable buffered data.
563 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200564 while (1) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100565 if (b->r > b->w)
Willy Tarreau83749182007-04-15 20:56:27 +0200566 max = b->r - b->w;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100567 else
Willy Tarreau83749182007-04-15 20:56:27 +0200568 max = b->data + BUFSIZE - b->w;
Willy Tarreau83749182007-04-15 20:56:27 +0200569
Willy Tarreauf890dc92008-12-13 21:12:26 +0100570 /* limit the amount of outgoing data if required */
571 if (max > b->send_max)
572 max = b->send_max;
573
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200574
575#ifdef TCP_CORK
576 /*
577 * Check if we want to cork output before sending. This typically occurs
578 * when there are data left in the buffer, or when we reached the end of
579 * buffer but we know we will close, so we try to merge the ongoing FIN
580 * with the last data segment.
581 */
582 if ((fdtab[si->fd].flags & (FD_FL_TCP|FD_FL_TCP_CORK)) == FD_FL_TCP) {
583 if (unlikely((b->send_max == b->l &&
584 (b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
585 (BF_WRITE_ENA|BF_SHUTR)))) {
586 /* we have to unconditionally reset TCP_NODELAY for CORK */
587 setsockopt(si->fd, IPPROTO_TCP, TCP_NODELAY, (char *) &zero, sizeof(zero));
588 setsockopt(si->fd, SOL_TCP, TCP_CORK, (char *) &one, sizeof(one));
589 fdtab[si->fd].flags = (fdtab[si->fd].flags & ~FD_FL_TCP_NODELAY) | FD_FL_TCP_CORK;
590 }
591 }
592#endif
593
Willy Tarreaubaaee002006-06-26 02:48:02 +0200594#ifndef MSG_NOSIGNAL
595 {
596 int skerr;
597 socklen_t lskerr = sizeof(skerr);
598
Willy Tarreau87bed622009-03-08 22:25:28 +0100599 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200600 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200601 ret = -1;
602 else
Willy Tarreau87bed622009-03-08 22:25:28 +0100603 ret = send(si->fd, b->w, max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200604 }
605#else
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100606 ret = send(si->fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200607#endif
608
609 if (ret > 0) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100610 if (fdtab[si->fd].state == FD_STCONN)
611 fdtab[si->fd].state = FD_STREADY;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100612
Willy Tarreau3da77c52008-08-29 09:58:42 +0200613 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200614
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100615 b->w += ret;
616 if (b->w == b->data + BUFSIZE)
617 b->w = b->data; /* wrap around the buffer */
618
619 b->l -= ret;
620 if (likely(b->l < b->max_len))
Willy Tarreaue393fe22008-08-16 22:18:07 +0200621 b->flags &= ~BF_FULL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100622
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100623 if (likely(!b->l)) {
624 /* optimize data alignment in the buffer */
625 b->r = b->w = b->lr = b->data;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100626 if (likely(!b->pipe))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100627 b->flags |= BF_EMPTY;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200628 }
Willy Tarreau83749182007-04-15 20:56:27 +0200629
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100630 b->send_max -= ret;
631 if (!b->send_max || !b->l)
632 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200633
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200634 /* if the system buffer is full, don't insist */
635 if (ret < max)
636 break;
637
Willy Tarreau6996e152007-04-30 14:37:43 +0200638 if (--write_poll <= 0)
639 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200640 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200641 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100642 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200643 retval = 0;
644 break;
645 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200646 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100647 /* bad, we got an error */
648 retval = -1;
649 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200650 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200651 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200652
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200653 /* check if we need to uncork the output, for instance when the
654 * output buffer is empty but not shutr().
655 */
656 if (unlikely((fdtab[si->fd].flags & (FD_FL_TCP|FD_FL_TCP_NODELAY)) == FD_FL_TCP && (b->flags & BF_EMPTY))) {
657 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) != (BF_WRITE_ENA|BF_SHUTR)) {
658#ifdef TCP_CORK
659 if (fdtab[si->fd].flags & FD_FL_TCP_CORK)
660 setsockopt(si->fd, SOL_TCP, TCP_CORK, (char *) &zero, sizeof(zero));
661#endif
662 setsockopt(si->fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
663 fdtab[si->fd].flags = (fdtab[si->fd].flags & ~FD_FL_TCP_CORK) | FD_FL_TCP_NODELAY;
664 }
665 }
666
667
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100668 return retval;
669}
Willy Tarreau6996e152007-04-30 14:37:43 +0200670
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100671
672/*
673 * This function is called on a write event from a stream socket.
674 * It returns 0 if the caller needs to poll before calling it again, otherwise
675 * non-zero.
676 */
677int stream_sock_write(int fd)
678{
679 struct stream_interface *si = fdtab[fd].owner;
680 struct buffer *b = si->ob;
681 int retval = 1;
682
683#ifdef DEBUG_FULL
684 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
685#endif
686
687 retval = 1;
688 if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR))
689 goto out_error;
690
Willy Tarreaud06e7112009-03-29 10:18:41 +0200691 /* we might have been called just after an asynchronous shutw */
692 if (b->flags & BF_SHUTW)
693 goto out_wakeup;
694
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100695 if (likely(!(b->flags & BF_EMPTY))) {
696 /* OK there are data waiting to be sent */
697 retval = stream_sock_write_loop(si, b);
698 if (retval < 0)
699 goto out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200700 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100701 else {
702 /* may be we have received a connection acknowledgement in TCP mode without data */
703 if (likely(fdtab[fd].state == FD_STCONN)) {
704 /* We have no data to send to check the connection, and
705 * getsockopt() will not inform us whether the connection
706 * is still pending. So we'll reuse connect() to check the
707 * state of the socket. This has the advantage of givig us
708 * the following info :
709 * - error
710 * - connecting (EALREADY, EINPROGRESS)
711 * - connected (EISCONN, 0)
712 */
713 if ((connect(fd, fdtab[fd].peeraddr, fdtab[fd].peerlen) == 0))
714 errno = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200715
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100716 if (errno == EALREADY || errno == EINPROGRESS) {
717 retval = 0;
718 goto out_may_wakeup;
719 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100720
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100721 if (errno && errno != EISCONN)
722 goto out_error;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200723
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100724 /* OK we just need to indicate that we got a connection
725 * and that we wrote nothing.
726 */
727 b->flags |= BF_WRITE_NULL;
728 fdtab[fd].state = FD_STREADY;
729 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200730
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100731 /* Funny, we were called to write something but there wasn't
732 * anything. We can get there, for example if we were woken up
733 * on a write event to finish the splice, but the send_max is 0
734 * so we cannot write anything from the buffer. Let's disable
735 * the write event and pretend we never came there.
736 */
737 }
738
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100739 if (!b->pipe && !b->send_max) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100740 /* the connection is established but we can't write. Either the
741 * buffer is empty, or we just refrain from sending because the
742 * send_max limit was reached. Maybe we just wrote the last
743 * chunk and need to close.
744 */
745 if (((b->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
746 (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) &&
747 (si->state == SI_ST_EST)) {
748 stream_sock_shutw(si);
749 goto out_wakeup;
750 }
751
Willy Tarreaud06e7112009-03-29 10:18:41 +0200752 if ((b->flags & (BF_EMPTY|BF_SHUTW)) == BF_EMPTY)
Willy Tarreauac128fe2009-01-09 13:05:19 +0100753 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100754
Willy Tarreauac128fe2009-01-09 13:05:19 +0100755 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100756 b->wex = TICK_ETERNITY;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100757 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100758
759 out_may_wakeup:
760 if (b->flags & BF_WRITE_ACTIVITY) {
761 /* update timeout if we have written something */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100762 if ((b->send_max || b->pipe) &&
Willy Tarreaud2def0f2009-01-18 17:37:33 +0100763 (b->flags & (BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100764 b->wex = tick_add_ifset(now_ms, b->wto);
765
766 out_wakeup:
767 if (tick_isset(si->ib->rex)) {
768 /* Note: to prevent the client from expiring read timeouts
769 * during writes, we refresh it. A better solution would be
770 * to merge read+write timeouts into a unique one, although
771 * that needs some study particularly on full-duplex TCP
772 * connections.
773 */
774 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
775 }
776
777 /* the producer might be waiting for more room to store data */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200778 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100779 (b->prod->flags & SI_FL_WAIT_ROOM)))
780 b->prod->chk_rcv(b->prod);
781
782 /* we have to wake up if there is a special event or if we don't have
783 * any more data to forward and it's not planned to send any more.
784 */
785 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100786 (!b->to_forward && !b->send_max && !b->pipe) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100787 si->state != SI_ST_EST ||
788 b->prod->state != SI_ST_EST))
789 task_wakeup(si->owner, TASK_WOKEN_IO);
790 }
791
792 fdtab[fd].ev &= ~FD_POLL_OUT;
793 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100794
Willy Tarreau6996e152007-04-30 14:37:43 +0200795 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100796 /* Write error on the file descriptor. We mark the FD as STERROR so
797 * that we don't use it anymore. The error is reported to the stream
798 * interface which will take proper action. We must not perturbate the
799 * buffer because the stream interface wants to ensure transparent
800 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200801 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100802
Willy Tarreau6996e152007-04-30 14:37:43 +0200803 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100804 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100805 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100806 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200807 task_wakeup(si->owner, TASK_WOKEN_IO);
808 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200809}
810
Willy Tarreau48adac52008-08-30 04:58:38 +0200811/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200812 * This function performs a shutdown-write on a stream interface in a connected or
813 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100814 * or closes the file descriptor and marks itself as closed. The buffer flags are
815 * updated to reflect the new state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200816 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100817void stream_sock_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200818{
Willy Tarreau99126c32008-11-27 10:30:51 +0100819 if (si->ob->flags & BF_SHUTW)
820 return;
821 si->ob->flags |= BF_SHUTW;
822 si->ob->wex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100823 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau99126c32008-11-27 10:30:51 +0100824
Willy Tarreaub38903c2008-11-23 21:33:29 +0100825 switch (si->state) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100826 case SI_ST_EST:
827 if (!(si->ib->flags & BF_SHUTR)) {
828 EV_FD_CLR(si->fd, DIR_WR);
829 shutdown(si->fd, SHUT_WR);
830 return;
831 }
832 /* fall through */
833 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100834 /* we may have to close a pending connection, and mark the
835 * response buffer as shutr
836 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200837 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100838 /* fall through */
839 case SI_ST_CER:
Willy Tarreau7f006512008-12-07 14:04:04 +0100840 si->state = SI_ST_DIS;
841 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200842 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100843 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100844 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100845 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100846 return;
Willy Tarreau48adac52008-08-30 04:58:38 +0200847 }
Willy Tarreau48adac52008-08-30 04:58:38 +0200848}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200849
Willy Tarreau2d212792008-08-27 21:41:35 +0200850/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200851 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100852 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100853 * or closes the file descriptor and marks itself as closed. The buffer flags are
854 * updated to reflect the new state.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200855 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100856void stream_sock_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200857{
Willy Tarreau99126c32008-11-27 10:30:51 +0100858 if (si->ib->flags & BF_SHUTR)
859 return;
860 si->ib->flags |= BF_SHUTR;
861 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100862 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100863
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100864 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100865 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200866
Willy Tarreaucff64112008-11-03 06:26:53 +0100867 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200868 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100869 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100870 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100871 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200872 }
873 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100874 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200875}
876
877/*
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200878 * Updates a connected stream_sock file descriptor status and timeouts
879 * according to the buffers' flags. It should only be called once after the
880 * buffer flags have settled down, and before they are cleared. It doesn't
881 * harm to call it as often as desired (it just slightly hurts performance).
882 */
Willy Tarreaub0253252008-11-30 21:37:12 +0100883void stream_sock_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200884{
Willy Tarreaub0253252008-11-30 21:37:12 +0100885 struct buffer *ib = si->ib;
886 struct buffer *ob = si->ob;
887 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200888
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200889 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 +0200890 now_ms, __FUNCTION__,
891 fd, fdtab[fd].owner,
892 ib, ob,
893 ib->rex, ob->wex,
894 ib->flags, ob->flags,
Willy Tarreaub0253252008-11-30 21:37:12 +0100895 ib->l, ob->l, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200896
897 /* Check if we need to close the read side */
898 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200899 /* Read not closed, update FD status and timeout for reads */
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200900 if (ib->flags & (BF_FULL|BF_HIJACK)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200901 /* stop reading */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100902 if ((ib->flags & (BF_FULL|BF_HIJACK)) == BF_FULL)
903 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200904 EV_FD_COND_C(fd, DIR_RD);
905 ib->rex = TICK_ETERNITY;
906 }
907 else {
908 /* (re)start reading and update timeout. Note: we don't recompute the timeout
909 * everytime we get here, otherwise it would risk never to expire. We only
910 * update it if is was not yet set, or if we already got some read status.
911 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100912 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200913 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreau86491c32008-12-14 09:04:47 +0100914 if (!(ib->flags & BF_READ_NOEXP) &&
915 (!tick_isset(ib->rex) || ib->flags & BF_READ_ACTIVITY))
Willy Tarreau2d212792008-08-27 21:41:35 +0200916 ib->rex = tick_add_ifset(now_ms, ib->rto);
917 }
918 }
919
920 /* Check if we need to close the write side */
921 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200922 /* Write not closed, update FD status and timeout for writes */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100923 if ((ob->send_max == 0 && !ob->pipe) ||
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100924 (ob->flags & BF_EMPTY) ||
Willy Tarreau3da77c52008-08-29 09:58:42 +0200925 (ob->flags & (BF_HIJACK|BF_WRITE_ENA)) == 0) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200926 /* stop writing */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100927 if ((ob->flags & (BF_EMPTY|BF_HIJACK|BF_WRITE_ENA)) == (BF_EMPTY|BF_WRITE_ENA))
928 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200929 EV_FD_COND_C(fd, DIR_WR);
930 ob->wex = TICK_ETERNITY;
931 }
932 else {
933 /* (re)start writing and update timeout. Note: we don't recompute the timeout
934 * everytime we get here, otherwise it would risk never to expire. We only
935 * update it if is was not yet set, or if we already got some write status.
936 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100937 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200938 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200939 if (!tick_isset(ob->wex) || ob->flags & BF_WRITE_ACTIVITY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200940 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreaud06e7112009-03-29 10:18:41 +0200941 if (tick_isset(ib->rex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200942 /* Note: depending on the protocol, we don't know if we're waiting
943 * for incoming data or not. So in order to prevent the socket from
944 * expiring read timeouts during writes, we refresh the read timeout,
945 * except if it was already infinite.
946 */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200947 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +0200948 }
949 }
950 }
951 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200952}
953
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100954/* This function is used for inter-stream-interface calls. It is called by the
955 * consumer to inform the producer side that it may be interested in checking
956 * for free space in the buffer. Note that it intentionally does not update
957 * timeouts, so that we can still check them later at wake-up.
958 */
959void stream_sock_chk_rcv(struct stream_interface *si)
960{
961 struct buffer *ib = si->ib;
962
963 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",
964 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +0000965 si->fd, fdtab[si->fd].owner,
966 ib, si->ob,
967 ib->rex, si->ob->wex,
968 ib->flags, si->ob->flags,
969 ib->l, si->ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100970
971 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
972 return;
973
974 if (ib->flags & (BF_FULL|BF_HIJACK)) {
975 /* stop reading */
976 if ((ib->flags & (BF_FULL|BF_HIJACK)) == BF_FULL)
977 si->flags |= SI_FL_WAIT_ROOM;
978 EV_FD_COND_C(si->fd, DIR_RD);
979 }
980 else {
981 /* (re)start reading */
982 si->flags &= ~SI_FL_WAIT_ROOM;
983 EV_FD_COND_S(si->fd, DIR_RD);
984 }
985}
986
987
988/* This function is used for inter-stream-interface calls. It is called by the
989 * producer to inform the consumer side that it may be interested in checking
990 * for data in the buffer. Note that it intentionally does not update timeouts,
991 * so that we can still check them later at wake-up.
992 */
993void stream_sock_chk_snd(struct stream_interface *si)
994{
995 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100996 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100997
998 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",
999 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001000 si->fd, fdtab[si->fd].owner,
1001 si->ib, ob,
1002 si->ib->rex, ob->wex,
1003 si->ib->flags, ob->flags,
1004 si->ib->l, ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001005
1006 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1007 return;
1008
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001009 if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1010 (fdtab[si->fd].ev & FD_POLL_OUT) || /* we'll be called anyway */
Willy Tarreau3eba98a2009-01-25 13:56:13 +01001011 !(ob->send_max || ob->pipe) || /* called with nothing to send ! */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001012 !(ob->flags & (BF_HIJACK|BF_WRITE_ENA))) /* we may not write */
1013 return;
1014
1015 retval = stream_sock_write_loop(si, ob);
1016 if (retval < 0) {
1017 /* Write error on the file descriptor. We mark the FD as STERROR so
1018 * that we don't use it anymore and we notify the task.
1019 */
1020 fdtab[si->fd].state = FD_STERROR;
1021 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001022 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001023 si->flags |= SI_FL_ERR;
1024 goto out_wakeup;
1025 }
1026
Willy Tarreau3eba98a2009-01-25 13:56:13 +01001027 if (retval > 0 || (ob->send_max == 0 && !ob->pipe)) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001028 /* the connection is established but we can't write. Either the
1029 * buffer is empty, or we just refrain from sending because the
1030 * send_max limit was reached. Maybe we just wrote the last
1031 * chunk and need to close.
1032 */
1033 if (((ob->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
1034 (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) &&
1035 (si->state == SI_ST_EST)) {
1036 stream_sock_shutw(si);
1037 goto out_wakeup;
1038 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001039
1040 if ((ob->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA)) == (BF_EMPTY|BF_WRITE_ENA))
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001041 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001042 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001043 }
1044 else {
1045 /* (re)start writing. */
1046 si->flags &= ~SI_FL_WAIT_DATA;
1047 EV_FD_COND_S(si->fd, DIR_WR);
1048 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001049
Willy Tarreauc9619462009-03-09 22:40:57 +01001050 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1051 /* update timeout if we have written something */
1052 if ((ob->send_max || ob->pipe) &&
1053 (ob->flags & (BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
1054 ob->wex = tick_add_ifset(now_ms, ob->wto);
1055
1056 if (tick_isset(si->ib->rex)) {
1057 /* Note: to prevent the client from expiring read timeouts
1058 * during writes, we refresh it. A better solution would be
1059 * to merge read+write timeouts into a unique one, although
1060 * that needs some study particularly on full-duplex TCP
1061 * connections.
1062 */
1063 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1064 }
1065 }
1066
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001067 /* in case of special condition (error, shutdown, end of write...), we
1068 * have to notify the task.
1069 */
1070 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreau3eba98a2009-01-25 13:56:13 +01001071 (!ob->to_forward && !ob->send_max && !ob->pipe) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001072 si->state != SI_ST_EST)) {
1073 out_wakeup:
1074 task_wakeup(si->owner, TASK_WOKEN_IO);
1075 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001076}
1077
Willy Tarreaubaaee002006-06-26 02:48:02 +02001078
1079/*
1080 * Local variables:
1081 * c-indent-level: 8
1082 * c-basic-offset: 8
1083 * End:
1084 */