blob: 1a824bd71b7f974367edbd09ac9ef8fa177bf045 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Functions operating on SOCK_STREAM and buffers.
3 *
Willy Tarreaua8f55d52010-05-31 17:44:19 +02004 * Copyright 2000-2010 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau6b4aad42009-01-18 21:59:13 +010013#define _GNU_SOURCE
Willy Tarreaubaaee002006-06-26 02:48:02 +020014#include <errno.h>
15#include <fcntl.h>
16#include <stdio.h>
17#include <stdlib.h>
18
19#include <sys/socket.h>
20#include <sys/stat.h>
21#include <sys/types.h>
22
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040023#include <netinet/tcp.h>
24
Willy Tarreau2dd0d472006-06-29 17:53:05 +020025#include <common/compat.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020026#include <common/config.h>
Willy Tarreaud6f087e2008-01-18 17:20:13 +010027#include <common/debug.h>
Willy Tarreau83749182007-04-15 20:56:27 +020028#include <common/standard.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020029#include <common/ticks.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020030#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020031
Willy Tarreau2d212792008-08-27 21:41:35 +020032#include <proto/buffers.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020033#include <proto/fd.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020034#include <proto/freq_ctr.h>
35#include <proto/log.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010036#include <proto/pipe.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020037#include <proto/stream_sock.h>
38#include <proto/task.h>
39
Willy Tarreau5bd8c372009-01-19 00:32:22 +010040#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020041
Willy Tarreau6b4aad42009-01-18 21:59:13 +010042/* On recent Linux kernels, the splice() syscall may be used for faster data copy.
43 * But it's not always defined on some OS versions, and it even happens that some
44 * definitions are wrong with some glibc due to an offset bug in syscall().
45 */
46
47#if defined(CONFIG_HAP_LINUX_SPLICE)
48#include <unistd.h>
49#include <sys/syscall.h>
50
51#ifndef SPLICE_F_MOVE
52#define SPLICE_F_MOVE 0x1
53#endif
54
55#ifndef SPLICE_F_NONBLOCK
56#define SPLICE_F_NONBLOCK 0x2
57#endif
58
59#ifndef SPLICE_F_MORE
60#define SPLICE_F_MORE 0x4
61#endif
62
63#ifndef __NR_splice
64#if defined(__powerpc__) || defined(__powerpc64__)
65#define __NR_splice 283
66#elif defined(__sparc__) || defined(__sparc64__)
67#define __NR_splice 232
68#elif defined(__x86_64__)
69#define __NR_splice 275
70#elif defined(__alpha__)
71#define __NR_splice 468
72#elif defined (__i386__)
73#define __NR_splice 313
74#else
75#warning unsupported architecture, guessing __NR_splice=313 like x86...
76#define __NR_splice 313
77#endif /* $arch */
78
79_syscall6(int, splice, int, fdin, loff_t *, off_in, int, fdout, loff_t *, off_out, size_t, len, unsigned long, flags)
80
81#endif /* __NR_splice */
Willy Tarreau5bd8c372009-01-19 00:32:22 +010082
83/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
84 * because of timestamps. Use this as a hint for not looping on splice().
85 */
86#define SPLICE_FULL_HINT 16*1448
87
Willy Tarreaua9de3332009-11-28 07:47:10 +010088/* how many data we attempt to splice at once when the buffer is configured for
89 * infinite forwarding */
90#define MAX_SPLICE_AT_ONCE (1<<30)
91
Willy Tarreau5bd8c372009-01-19 00:32:22 +010092/* Returns :
93 * -1 if splice is not possible or not possible anymore and we must switch to
94 * user-land copy (eg: to_forward reached)
95 * 0 when we know that polling is required to get more data (EAGAIN)
96 * 1 for all other cases (we can safely try again, or if an activity has been
97 * detected (DATA/NULL/ERR))
98 * Sets :
99 * BF_READ_NULL
100 * BF_READ_PARTIAL
101 * BF_WRITE_PARTIAL (during copy)
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200102 * BF_OUT_EMPTY (during copy)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100103 * SI_FL_ERR
104 * SI_FL_WAIT_ROOM
105 * (SI_FL_WAIT_RECV)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100106 *
107 * This function automatically allocates a pipe from the pipe pool. It also
108 * carefully ensures to clear b->pipe whenever it leaves the pipe empty.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100109 */
110static int stream_sock_splice_in(struct buffer *b, struct stream_interface *si)
111{
112 int fd = si->fd;
Willy Tarreau31971e52009-09-20 12:07:52 +0200113 int ret;
114 unsigned long max;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100115 int retval = 1;
116
117 if (!b->to_forward)
118 return -1;
119
120 if (!(b->flags & BF_KERN_SPLICING))
121 return -1;
122
123 if (b->l) {
124 /* We're embarrassed, there are already data pending in
125 * the buffer and we don't want to have them at two
126 * locations at a time. Let's indicate we need some
127 * place and ask the consumer to hurry.
128 */
129 si->flags |= SI_FL_WAIT_ROOM;
130 EV_FD_CLR(fd, DIR_RD);
131 b->rex = TICK_ETERNITY;
132 b->cons->chk_snd(b->cons);
133 return 1;
134 }
135
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100136 if (unlikely(b->pipe == NULL)) {
137 if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100138 b->flags &= ~BF_KERN_SPLICING;
139 return -1;
140 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100141 }
142
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100143 /* At this point, b->pipe is valid */
144
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100145 while (1) {
Willy Tarreaua9de3332009-11-28 07:47:10 +0100146 if (b->to_forward == BUF_INFINITE_FORWARD)
147 max = MAX_SPLICE_AT_ONCE;
148 else
149 max = b->to_forward;
150
Willy Tarreau31971e52009-09-20 12:07:52 +0200151 if (!max) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100152 /* It looks like the buffer + the pipe already contain
153 * the maximum amount of data to be transferred. Try to
154 * send those data immediately on the other side if it
155 * is currently waiting.
156 */
157 retval = -1; /* end of forwarding */
158 break;
159 }
160
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100161 ret = splice(fd, NULL, b->pipe->prod, NULL, max,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100162 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
163
164 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100165 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100166 /* connection closed. This is only detected by
167 * recent kernels (>= 2.6.27.13).
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100168 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100169 b->flags |= BF_READ_NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100170 retval = 1; /* no need for further polling */
171 break;
172 }
173
174 if (errno == EAGAIN) {
175 /* there are two reasons for EAGAIN :
176 * - nothing in the socket buffer (standard)
177 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100178 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100179 * Since we don't know if pipe is full, we'll
180 * stop if the pipe is not empty. Anyway, we
181 * will almost always fill/empty the pipe.
182 */
183
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100184 if (b->pipe->data) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100185 si->flags |= SI_FL_WAIT_ROOM;
186 retval = 1;
187 break;
188 }
189
Willy Tarreau98b306b2009-01-25 11:11:32 +0100190 /* We don't know if the connection was closed.
191 * But if we're called upon POLLIN with an empty
192 * pipe and get EAGAIN, it is suspect enought to
193 * try to fall back to the normal recv scheme
194 * which will be able to deal with the situation.
195 */
196 retval = -1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100197 break;
198 }
Willy Tarreaudc340a92009-06-28 23:10:19 +0200199
Willy Tarreaua9de3332009-11-28 07:47:10 +0100200 if (errno == ENOSYS || errno == EINVAL) {
Willy Tarreaudc340a92009-06-28 23:10:19 +0200201 /* splice not supported on this end, disable it */
202 b->flags &= ~BF_KERN_SPLICING;
203 si->flags &= ~SI_FL_CAP_SPLICE;
204 put_pipe(b->pipe);
205 b->pipe = NULL;
206 return -1;
207 }
208
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100209 /* here we have another error */
210 si->flags |= SI_FL_ERR;
211 retval = 1;
212 break;
213 } /* ret <= 0 */
214
Willy Tarreau31971e52009-09-20 12:07:52 +0200215 if (b->to_forward != BUF_INFINITE_FORWARD)
216 b->to_forward -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100217 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100218 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100219 b->flags |= BF_READ_PARTIAL;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200220 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100221
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100222 if (b->pipe->data >= SPLICE_FULL_HINT ||
223 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100224 /* We've read enough of it for this time. */
225 retval = 1;
226 break;
227 }
228 } /* while */
229
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100230 if (unlikely(!b->pipe->data)) {
231 put_pipe(b->pipe);
232 b->pipe = NULL;
233 }
234
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100235 return retval;
236}
237
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100238#endif /* CONFIG_HAP_LINUX_SPLICE */
239
240
Willy Tarreaubaaee002006-06-26 02:48:02 +0200241/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200242 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200243 * It returns 0 if we have a high confidence that we will not be
244 * able to read more data without polling first. Returns non-zero
245 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200246 */
Willy Tarreaud7971282006-07-29 18:36:34 +0200247int stream_sock_read(int fd) {
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200248 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200249 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200250 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100251 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200252
253#ifdef DEBUG_FULL
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100254 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 +0200255#endif
256
Willy Tarreau83749182007-04-15 20:56:27 +0200257 retval = 1;
258
Willy Tarreau71543652009-07-14 19:55:05 +0200259 /* stop immediately on errors. Note that we DON'T want to stop on
260 * POLL_ERR, as the poller might report a write error while there
261 * are still data available in the recv buffer. This typically
262 * happens when we send too large a request to a backend server
263 * which rejects it before reading it all.
264 */
265 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200266 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100267
268 /* stop here if we reached the end of data */
269 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
270 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200271
Willy Tarreaud06e7112009-03-29 10:18:41 +0200272 /* maybe we were called immediately after an asynchronous shutr */
273 if (b->flags & BF_SHUTR)
274 goto out_wakeup;
275
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100276#if defined(CONFIG_HAP_LINUX_SPLICE)
277 if (b->to_forward && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100278
279 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
280 * Since older splice() implementations were buggy and returned
281 * EAGAIN on end of read, let's bypass the call to splice() now.
282 */
283 if (fdtab[fd].ev & FD_POLL_HUP)
284 goto out_shutdown_r;
285
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100286 retval = stream_sock_splice_in(b, si);
287
288 if (retval >= 0) {
289 if (si->flags & SI_FL_ERR)
290 goto out_error;
291 if (b->flags & BF_READ_NULL)
292 goto out_shutdown_r;
293 goto out_wakeup;
294 }
295 /* splice not possible (anymore), let's go on on standard copy */
296 }
297#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200298 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200299 while (1) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100300 max = buffer_max_len(b) - b->l;
301
302 if (max <= 0) {
303 b->flags |= BF_FULL;
304 si->flags |= SI_FL_WAIT_ROOM;
305 break;
306 }
307
Willy Tarreau6996e152007-04-30 14:37:43 +0200308 /*
309 * 1. compute the maximum block size we can read at once.
310 */
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100311 if (b->l == 0) {
312 /* let's realign the buffer to optimize I/O */
313 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200314 }
315 else if (b->r > b->w) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100316 /* remaining space wraps at the end, with a moving limit */
317 if (max > b->data + b->size - b->r)
318 max = b->data + b->size - b->r;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100319 }
Willy Tarreau864e8252009-12-28 17:36:37 +0100320 /* else max is already OK */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200321
Willy Tarreau6996e152007-04-30 14:37:43 +0200322 /*
323 * 2. read the largest possible block
324 */
Willy Tarreaufc1daaf2010-01-15 10:26:13 +0100325 ret = recv(fd, b->r, max, 0);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200326
Willy Tarreau83749182007-04-15 20:56:27 +0200327 if (ret > 0) {
328 b->r += ret;
329 b->l += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200330 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100331
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100332 /* if we're allowed to directly forward data, we must update send_max */
Willy Tarreau31971e52009-09-20 12:07:52 +0200333 if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
334 unsigned long fwd = ret;
335 if (b->to_forward != BUF_INFINITE_FORWARD) {
336 if (fwd > b->to_forward)
337 fwd = b->to_forward;
338 b->to_forward -= fwd;
339 }
340 b->send_max += fwd;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200341 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100342 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100343
Willy Tarreaub38903c2008-11-23 21:33:29 +0100344 if (fdtab[fd].state == FD_STCONN)
345 fdtab[fd].state = FD_STREADY;
346
Willy Tarreau3da77c52008-08-29 09:58:42 +0200347 b->flags |= BF_READ_PARTIAL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100348
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200349 if (b->r == b->data + b->size) {
Willy Tarreau83749182007-04-15 20:56:27 +0200350 b->r = b->data; /* wrap around the buffer */
351 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100352
Willy Tarreau83749182007-04-15 20:56:27 +0200353 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100354
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100355 if (b->l >= buffer_max_len(b)) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200356 /* The buffer is now full, there's no point in going through
357 * the loop again.
358 */
Willy Tarreau8a7af602008-05-03 23:07:14 +0200359 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) {
360 b->xfer_small = 0;
361 b->xfer_large++;
362 if (b->xfer_large >= 3) {
363 /* we call this buffer a fast streamer if it manages
364 * to be filled in one call 3 consecutive times.
365 */
366 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
367 //fputc('+', stderr);
368 }
369 }
370 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200371 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200372 b->xfer_large = 0;
373 b->xfer_small++;
374 if (b->xfer_small >= 2) {
375 /* if the buffer has been at least half full twice,
376 * we receive faster than we send, so at least it
377 * is not a "fast streamer".
378 */
379 b->flags &= ~BF_STREAMER_FAST;
380 //fputc('-', stderr);
381 }
382 }
383 else {
384 b->xfer_small = 0;
385 b->xfer_large = 0;
386 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100387
388 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100389 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100390 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200391 }
392
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200393 /* if too many bytes were missing from last read, it means that
394 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100395 * not have them in buffers. BTW, if FD_POLL_HUP was present,
396 * it means that we have reached the end and that the connection
397 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200398 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100399 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200400 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200401 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200402 b->xfer_large = 0;
403 b->xfer_small++;
404 if (b->xfer_small >= 3) {
405 /* we have read less than half of the buffer in
406 * one pass, and this happened at least 3 times.
407 * This is definitely not a streamer.
408 */
409 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
410 //fputc('!', stderr);
411 }
412 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200413 /* unfortunately, on level-triggered events, POLL_HUP
414 * is generally delivered AFTER the system buffer is
415 * empty, so this one might never match.
416 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100417 if (fdtab[fd].ev & FD_POLL_HUP)
418 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200419
420 /* if a streamer has read few data, it may be because we
421 * have exhausted system buffers. It's not worth trying
422 * again.
423 */
424 if (b->flags & BF_STREAMER)
425 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200426
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100427 /* generally if we read something smaller than 1 or 2 MSS,
428 * it means that either we have exhausted the system's
429 * buffers (streamer or question-response protocol) or
430 * that the connection will be closed. Streamers are
431 * easily detected so we return early. For other cases,
432 * it's still better to perform a last read to be sure,
433 * because it may save one complete poll/read/wakeup cycle
434 * in case of shutdown.
435 */
436 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
437 break;
438
439 /* if we read a large block smaller than what we requested,
440 * it's almost certain we'll never get anything more.
441 */
442 if (ret >= global.tune.recv_enough)
443 break;
444 }
Willy Tarreau83749182007-04-15 20:56:27 +0200445
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100446 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200447 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200448 }
449 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200450 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100451 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200452 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200453 else if (errno == EAGAIN) {
454 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100455 * nothing to read left if we did not read much, ie
456 * less than what we were still expecting to read.
457 * But we may have done some work justifying to notify
458 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200459 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100460 if (cur_read < MIN_RET_FOR_READ_LOOP)
461 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200462 break;
463 }
464 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200465 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200466 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200467 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200468
Willy Tarreau6996e152007-04-30 14:37:43 +0200469 out_wakeup:
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100470 /* We might have some data the consumer is waiting for */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200471 if (!(b->flags & BF_OUT_EMPTY) && (b->cons->flags & SI_FL_WAIT_DATA)) {
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100472 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100473
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100474 b->cons->chk_snd(b->cons);
475
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100476 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100477 if (!(b->flags & BF_FULL) &&
478 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100479 si->flags &= ~SI_FL_WAIT_ROOM;
480 }
481
482 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100483 EV_FD_CLR(fd, DIR_RD);
484 b->rex = TICK_ETERNITY;
485 }
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200486 else if ((b->flags & (BF_SHUTR|BF_READ_PARTIAL|BF_FULL|BF_DONT_READ|BF_READ_NOEXP)) == BF_READ_PARTIAL)
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100487 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100488
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100489 /* we have to wake up if there is a special event or if we don't have
490 * any more data to forward.
491 */
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200492 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100493 si->state != SI_ST_EST ||
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200494 (si->flags & SI_FL_ERR) ||
495 ((b->flags & BF_READ_PARTIAL) && (!b->to_forward || b->cons->state != SI_ST_EST)))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100496 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200497
498 if (b->flags & BF_READ_ACTIVITY)
499 b->flags &= ~BF_READ_DONTWAIT;
500
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100501 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200502 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200503
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100504 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200505 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100506 fdtab[fd].ev &= ~FD_POLL_HUP;
507 b->flags |= BF_READ_NULL;
Willy Tarreau520d95e2009-09-19 21:04:57 +0200508 if (b->flags & BF_AUTO_CLOSE)
Willy Tarreau418fd472009-09-06 21:37:23 +0200509 buffer_shutw_now(b);
Willy Tarreau99126c32008-11-27 10:30:51 +0100510 stream_sock_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200511 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100512
Willy Tarreau6996e152007-04-30 14:37:43 +0200513 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100514 /* Read error on the file descriptor. We mark the FD as STERROR so
515 * that we don't use it anymore. The error is reported to the stream
516 * interface which will take proper action. We must not perturbate the
517 * buffer because the stream interface wants to ensure transparent
518 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200519 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100520
Willy Tarreau6996e152007-04-30 14:37:43 +0200521 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100522 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100523 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100524 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100525 retval = 1;
526 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200527}
528
529
530/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100531 * This function is called to send buffer data to a stream socket.
532 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100533 * before calling it again, otherwise 1. If a pipe was associated with the
534 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200535 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100536static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100537{
Willy Tarreau83749182007-04-15 20:56:27 +0200538 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100539 int retval = 1;
540 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200541
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100542#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100543 while (b->pipe) {
544 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100545 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
546 if (ret <= 0) {
547 if (ret == 0 || errno == EAGAIN) {
548 retval = 0;
549 return retval;
550 }
551 /* here we have another error */
552 retval = -1;
553 return retval;
554 }
555
556 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100557 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100558
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100559 if (!b->pipe->data) {
560 put_pipe(b->pipe);
561 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100562 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100563 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100564
565 if (--write_poll <= 0)
566 return retval;
567 }
568
569 /* At this point, the pipe is empty, but we may still have data pending
570 * in the normal buffer.
571 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100572#endif
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200573 if (!b->send_max) {
574 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100575 return retval;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200576 }
Willy Tarreau83749182007-04-15 20:56:27 +0200577
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100578 /* when we're in this loop, we already know that there is no spliced
579 * data left, and that there are sendable buffered data.
580 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200581 while (1) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100582 if (b->r > b->w)
Willy Tarreau83749182007-04-15 20:56:27 +0200583 max = b->r - b->w;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100584 else
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200585 max = b->data + b->size - b->w;
Willy Tarreau83749182007-04-15 20:56:27 +0200586
Willy Tarreauf890dc92008-12-13 21:12:26 +0100587 /* limit the amount of outgoing data if required */
588 if (max > b->send_max)
589 max = b->send_max;
590
Willy Tarreau6db06d32009-08-19 11:14:11 +0200591 /* check if we want to inform the kernel that we're interested in
592 * sending more data after this call. We want this if :
593 * - we're about to close after this last send and want to merge
594 * the ongoing FIN with the last segment.
595 * - we know we can't send everything at once and must get back
596 * here because of unaligned data
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100597 * - there is still a finite amount of data to forward
Willy Tarreau6db06d32009-08-19 11:14:11 +0200598 * The test is arranged so that the most common case does only 2
599 * tests.
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200600 */
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200601
Willy Tarreauface8392010-01-03 11:37:54 +0100602 if (MSG_NOSIGNAL && MSG_MORE) {
Willy Tarreau6db06d32009-08-19 11:14:11 +0200603 unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
604
Willy Tarreauface8392010-01-03 11:37:54 +0100605 if (((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100606 ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->send_max)) ||
Willy Tarreau6db06d32009-08-19 11:14:11 +0200607 (max != b->l && max != b->send_max))
608 && (fdtab[si->fd].flags & FD_FL_TCP)) {
609 send_flag |= MSG_MORE;
610 }
Willy Tarreauface8392010-01-03 11:37:54 +0100611 else if (b->flags & BF_EXPECT_MORE) {
612 /* it was forced on the buffer, this flag is one-shoot */
613 b->flags &= ~BF_EXPECT_MORE;
614 send_flag |= MSG_MORE;
615 }
Willy Tarreau6db06d32009-08-19 11:14:11 +0200616
Willy Tarreau2be39392010-01-03 17:24:51 +0100617 /* this flag has precedence over the rest */
618 if (b->flags & BF_SEND_DONTWAIT)
619 send_flag &= ~MSG_MORE;
620
Willy Tarreau6db06d32009-08-19 11:14:11 +0200621 ret = send(si->fd, b->w, max, send_flag);
Willy Tarreau2be39392010-01-03 17:24:51 +0100622
623 /* disable it only once everything has been sent */
624 if (ret == max && (b->flags & BF_SEND_DONTWAIT))
625 b->flags &= ~BF_SEND_DONTWAIT;
Willy Tarreaud6d06902009-08-19 11:22:33 +0200626 } else {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200627 int skerr;
628 socklen_t lskerr = sizeof(skerr);
629
Willy Tarreau87bed622009-03-08 22:25:28 +0100630 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200631 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200632 ret = -1;
633 else
Willy Tarreau87bed622009-03-08 22:25:28 +0100634 ret = send(si->fd, b->w, max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200635 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200636
637 if (ret > 0) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100638 if (fdtab[si->fd].state == FD_STCONN)
639 fdtab[si->fd].state = FD_STREADY;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100640
Willy Tarreau3da77c52008-08-29 09:58:42 +0200641 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200642
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100643 b->w += ret;
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200644 if (b->w == b->data + b->size)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100645 b->w = b->data; /* wrap around the buffer */
646
647 b->l -= ret;
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100648 if (likely(b->l < buffer_max_len(b)))
Willy Tarreaue393fe22008-08-16 22:18:07 +0200649 b->flags &= ~BF_FULL;
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100650
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200651 if (likely(!b->l))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100652 /* optimize data alignment in the buffer */
653 b->r = b->w = b->lr = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200654
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100655 b->send_max -= ret;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200656 if (!b->send_max) {
657 if (likely(!b->pipe))
658 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100659 break;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200660 }
Willy Tarreau83749182007-04-15 20:56:27 +0200661
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200662 /* if the system buffer is full, don't insist */
663 if (ret < max)
664 break;
665
Willy Tarreau6996e152007-04-30 14:37:43 +0200666 if (--write_poll <= 0)
667 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200668 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200669 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100670 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200671 retval = 0;
672 break;
673 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200674 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100675 /* bad, we got an error */
676 retval = -1;
677 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200678 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200679 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200680
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100681 return retval;
682}
Willy Tarreau6996e152007-04-30 14:37:43 +0200683
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100684
685/*
686 * This function is called on a write event from a stream socket.
687 * It returns 0 if the caller needs to poll before calling it again, otherwise
688 * non-zero.
689 */
690int stream_sock_write(int fd)
691{
692 struct stream_interface *si = fdtab[fd].owner;
693 struct buffer *b = si->ob;
694 int retval = 1;
695
696#ifdef DEBUG_FULL
697 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
698#endif
699
700 retval = 1;
Willy Tarreau71543652009-07-14 19:55:05 +0200701 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100702 goto out_error;
703
Willy Tarreaud06e7112009-03-29 10:18:41 +0200704 /* we might have been called just after an asynchronous shutw */
705 if (b->flags & BF_SHUTW)
706 goto out_wakeup;
707
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200708 if (likely(!(b->flags & BF_OUT_EMPTY))) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100709 /* OK there are data waiting to be sent */
710 retval = stream_sock_write_loop(si, b);
711 if (retval < 0)
712 goto out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200713 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100714 else {
715 /* may be we have received a connection acknowledgement in TCP mode without data */
716 if (likely(fdtab[fd].state == FD_STCONN)) {
717 /* We have no data to send to check the connection, and
718 * getsockopt() will not inform us whether the connection
719 * is still pending. So we'll reuse connect() to check the
720 * state of the socket. This has the advantage of givig us
721 * the following info :
722 * - error
723 * - connecting (EALREADY, EINPROGRESS)
724 * - connected (EISCONN, 0)
725 */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +0200726 if ((connect(fd, fdinfo[fd].peeraddr, fdinfo[fd].peerlen) == 0))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100727 errno = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200728
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100729 if (errno == EALREADY || errno == EINPROGRESS) {
730 retval = 0;
731 goto out_may_wakeup;
732 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100733
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100734 if (errno && errno != EISCONN)
735 goto out_error;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200736
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100737 /* OK we just need to indicate that we got a connection
738 * and that we wrote nothing.
739 */
740 b->flags |= BF_WRITE_NULL;
741 fdtab[fd].state = FD_STREADY;
742 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200743
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100744 /* Funny, we were called to write something but there wasn't
745 * anything. We can get there, for example if we were woken up
746 * on a write event to finish the splice, but the send_max is 0
747 * so we cannot write anything from the buffer. Let's disable
748 * the write event and pretend we never came there.
749 */
750 }
751
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200752 if (b->flags & BF_OUT_EMPTY) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100753 /* the connection is established but we can't write. Either the
754 * buffer is empty, or we just refrain from sending because the
755 * send_max limit was reached. Maybe we just wrote the last
756 * chunk and need to close.
757 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200758 if (((b->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100759 (si->state == SI_ST_EST)) {
760 stream_sock_shutw(si);
761 goto out_wakeup;
762 }
763
Willy Tarreau59454bf2009-09-20 11:13:40 +0200764 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreauac128fe2009-01-09 13:05:19 +0100765 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100766
Willy Tarreauac128fe2009-01-09 13:05:19 +0100767 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100768 b->wex = TICK_ETERNITY;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100769 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100770
771 out_may_wakeup:
772 if (b->flags & BF_WRITE_ACTIVITY) {
773 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200774 if ((b->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100775 b->wex = tick_add_ifset(now_ms, b->wto);
776
777 out_wakeup:
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200778 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100779 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200780 * during writes, we refresh it. We only do this if the
781 * interface is not configured for "independant streams",
782 * because for some applications it's better not to do this,
783 * for instance when continuously exchanging small amounts
784 * of data which can full the socket buffers long before a
785 * write timeout is detected.
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100786 */
787 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
788 }
789
790 /* the producer might be waiting for more room to store data */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200791 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100792 (b->prod->flags & SI_FL_WAIT_ROOM)))
793 b->prod->chk_rcv(b->prod);
794
795 /* we have to wake up if there is a special event or if we don't have
796 * any more data to forward and it's not planned to send any more.
797 */
798 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200799 ((b->flags & BF_OUT_EMPTY) && !b->to_forward) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100800 si->state != SI_ST_EST ||
801 b->prod->state != SI_ST_EST))
802 task_wakeup(si->owner, TASK_WOKEN_IO);
803 }
804
805 fdtab[fd].ev &= ~FD_POLL_OUT;
806 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100807
Willy Tarreau6996e152007-04-30 14:37:43 +0200808 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100809 /* Write error on the file descriptor. We mark the FD as STERROR so
810 * that we don't use it anymore. The error is reported to the stream
811 * interface which will take proper action. We must not perturbate the
812 * buffer because the stream interface wants to ensure transparent
813 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200814 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100815
Willy Tarreau6996e152007-04-30 14:37:43 +0200816 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100817 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100818 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100819 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200820 task_wakeup(si->owner, TASK_WOKEN_IO);
821 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200822}
823
Willy Tarreau48adac52008-08-30 04:58:38 +0200824/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200825 * This function performs a shutdown-write on a stream interface in a connected or
826 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100827 * or closes the file descriptor and marks itself as closed. The buffer flags are
Willy Tarreau7340ca52010-01-16 10:03:45 +0100828 * updated to reflect the new state. It does also close everything is the SI was
829 * marked as being in error state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200830 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100831void stream_sock_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200832{
Willy Tarreau418fd472009-09-06 21:37:23 +0200833 si->ob->flags &= ~BF_SHUTW_NOW;
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.
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100845 * However, if SI_FL_NOLINGER is explicitly set, we know there is
846 * no risk so we close both sides immediately.
Willy Tarreau720058c2009-07-14 19:21:50 +0200847 */
Willy Tarreau7340ca52010-01-16 10:03:45 +0100848 if (si->flags & SI_FL_ERR) {
849 /* quick close, the socket is already shut. Remove pending flags. */
850 si->flags &= ~SI_FL_NOLINGER;
851 } else if (si->flags & SI_FL_NOLINGER) {
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100852 si->flags &= ~SI_FL_NOLINGER;
853 setsockopt(si->fd, SOL_SOCKET, SO_LINGER,
854 (struct linger *) &nolinger, sizeof(struct linger));
855 } else {
856 EV_FD_CLR(si->fd, DIR_WR);
857 shutdown(si->fd, SHUT_WR);
Willy Tarreau720058c2009-07-14 19:21:50 +0200858
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100859 if (!(si->ib->flags & (BF_SHUTR|BF_DONT_READ)))
860 return;
861 }
Willy Tarreau5d707e12009-06-28 11:09:07 +0200862
Willy Tarreaub38903c2008-11-23 21:33:29 +0100863 /* fall through */
864 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100865 /* we may have to close a pending connection, and mark the
866 * response buffer as shutr
867 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200868 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100869 /* fall through */
870 case SI_ST_CER:
Willy Tarreau7f006512008-12-07 14:04:04 +0100871 si->state = SI_ST_DIS;
872 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200873 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100874 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100875 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100876 si->exp = TICK_ETERNITY;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100877 return;
Willy Tarreau48adac52008-08-30 04:58:38 +0200878 }
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200879
880 if (si->release)
881 si->release(si);
Willy Tarreau48adac52008-08-30 04:58:38 +0200882}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200883
Willy Tarreau2d212792008-08-27 21:41:35 +0200884/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200885 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100886 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100887 * or closes the file descriptor and marks itself as closed. The buffer flags are
888 * updated to reflect the new state.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200889 */
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100890void stream_sock_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200891{
Willy Tarreau418fd472009-09-06 21:37:23 +0200892 si->ib->flags &= ~BF_SHUTR_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100893 if (si->ib->flags & BF_SHUTR)
894 return;
895 si->ib->flags |= BF_SHUTR;
896 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100897 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100898
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100899 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100900 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200901
Willy Tarreaucff64112008-11-03 06:26:53 +0100902 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200903 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100904 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100905 si->exp = TICK_ETERNITY;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200906
907 if (si->release)
908 si->release(si);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100909 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200910 }
911 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100912 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200913}
914
915/*
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200916 * Updates a connected stream_sock file descriptor status and timeouts
917 * according to the buffers' flags. It should only be called once after the
918 * buffer flags have settled down, and before they are cleared. It doesn't
919 * harm to call it as often as desired (it just slightly hurts performance).
920 */
Willy Tarreaub0253252008-11-30 21:37:12 +0100921void stream_sock_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200922{
Willy Tarreaub0253252008-11-30 21:37:12 +0100923 struct buffer *ib = si->ib;
924 struct buffer *ob = si->ob;
925 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200926
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200927 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 +0200928 now_ms, __FUNCTION__,
929 fd, fdtab[fd].owner,
930 ib, ob,
931 ib->rex, ob->wex,
932 ib->flags, ob->flags,
Willy Tarreaub0253252008-11-30 21:37:12 +0100933 ib->l, ob->l, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200934
935 /* Check if we need to close the read side */
936 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200937 /* Read not closed, update FD status and timeout for reads */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200938 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200939 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200940 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100941 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200942 EV_FD_COND_C(fd, DIR_RD);
943 ib->rex = TICK_ETERNITY;
944 }
945 else {
946 /* (re)start reading and update timeout. Note: we don't recompute the timeout
947 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200948 * update it if is was not yet set. The stream socket handler will already
949 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200950 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100951 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200952 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200953 if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
Willy Tarreau2d212792008-08-27 21:41:35 +0200954 ib->rex = tick_add_ifset(now_ms, ib->rto);
955 }
956 }
957
958 /* Check if we need to close the write side */
959 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200960 /* Write not closed, update FD status and timeout for writes */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200961 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200962 /* stop writing */
Willy Tarreau59454bf2009-09-20 11:13:40 +0200963 if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100964 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200965 EV_FD_COND_C(fd, DIR_WR);
966 ob->wex = TICK_ETERNITY;
967 }
968 else {
969 /* (re)start writing and update timeout. Note: we don't recompute the timeout
970 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200971 * update it if is was not yet set. The stream socket handler will already
972 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200973 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100974 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200975 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200976 if (!tick_isset(ob->wex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200977 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200978 if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200979 /* Note: depending on the protocol, we don't know if we're waiting
980 * for incoming data or not. So in order to prevent the socket from
981 * expiring read timeouts during writes, we refresh the read timeout,
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200982 * except if it was already infinite or if we have explicitly setup
983 * independant streams.
Willy Tarreau2d212792008-08-27 21:41:35 +0200984 */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200985 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +0200986 }
987 }
988 }
989 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200990}
991
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100992/* This function is used for inter-stream-interface calls. It is called by the
993 * consumer to inform the producer side that it may be interested in checking
994 * for free space in the buffer. Note that it intentionally does not update
995 * timeouts, so that we can still check them later at wake-up.
996 */
997void stream_sock_chk_rcv(struct stream_interface *si)
998{
999 struct buffer *ib = si->ib;
1000
1001 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",
1002 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001003 si->fd, fdtab[si->fd].owner,
1004 ib, si->ob,
1005 ib->rex, si->ob->wex,
1006 ib->flags, si->ob->flags,
1007 ib->l, si->ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001008
1009 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
1010 return;
1011
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001012 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001013 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001014 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001015 si->flags |= SI_FL_WAIT_ROOM;
1016 EV_FD_COND_C(si->fd, DIR_RD);
1017 }
1018 else {
1019 /* (re)start reading */
1020 si->flags &= ~SI_FL_WAIT_ROOM;
1021 EV_FD_COND_S(si->fd, DIR_RD);
1022 }
1023}
1024
1025
1026/* This function is used for inter-stream-interface calls. It is called by the
1027 * producer to inform the consumer side that it may be interested in checking
1028 * for data in the buffer. Note that it intentionally does not update timeouts,
1029 * so that we can still check them later at wake-up.
1030 */
1031void stream_sock_chk_snd(struct stream_interface *si)
1032{
1033 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001034 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001035
1036 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",
1037 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001038 si->fd, fdtab[si->fd].owner,
1039 si->ib, ob,
1040 si->ib->rex, ob->wex,
1041 si->ib->flags, ob->flags,
1042 si->ib->l, ob->l, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001043
1044 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1045 return;
1046
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001047 if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1048 (fdtab[si->fd].ev & FD_POLL_OUT) || /* we'll be called anyway */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001049 (ob->flags & BF_OUT_EMPTY)) /* called with nothing to send ! */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001050 return;
1051
1052 retval = stream_sock_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001053 /* here, we have :
1054 * retval < 0 if an error was encountered during write.
1055 * retval = 0 if we can't write anymore without polling
1056 * retval = 1 if we're invited to come back when desired
1057 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001058 if (retval < 0) {
1059 /* Write error on the file descriptor. We mark the FD as STERROR so
1060 * that we don't use it anymore and we notify the task.
1061 */
1062 fdtab[si->fd].state = FD_STERROR;
1063 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001064 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001065 si->flags |= SI_FL_ERR;
1066 goto out_wakeup;
1067 }
1068
Willy Tarreauc54aef32009-07-27 20:08:06 +02001069 /* OK, so now we know that retval >= 0 means that some data might have
1070 * been sent, and that we may have to poll first. We have to do that
1071 * too if the buffer is not empty.
1072 */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001073 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001074 /* the connection is established but we can't write. Either the
1075 * buffer is empty, or we just refrain from sending because the
1076 * send_max limit was reached. Maybe we just wrote the last
1077 * chunk and need to close.
1078 */
Willy Tarreau520d95e2009-09-19 21:04:57 +02001079 if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
1080 (BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001081 (si->state == SI_ST_EST)) {
1082 stream_sock_shutw(si);
1083 goto out_wakeup;
1084 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001085
Willy Tarreau59454bf2009-09-20 11:13:40 +02001086 if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001087 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001088 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001089 }
1090 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +02001091 /* Otherwise there are remaining data to be sent in the buffer,
1092 * which means we have to poll before doing so.
1093 */
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001094 EV_FD_COND_S(si->fd, DIR_WR);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001095 si->flags &= ~SI_FL_WAIT_DATA;
1096 if (!tick_isset(ob->wex))
1097 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001098 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001099
Willy Tarreauc9619462009-03-09 22:40:57 +01001100 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1101 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001102 if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreauc9619462009-03-09 22:40:57 +01001103 ob->wex = tick_add_ifset(now_ms, ob->wto);
1104
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001105 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreauc9619462009-03-09 22:40:57 +01001106 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001107 * during writes, we refresh it. We only do this if the
1108 * interface is not configured for "independant streams",
1109 * because for some applications it's better not to do this,
1110 * for instance when continuously exchanging small amounts
1111 * of data which can full the socket buffers long before a
1112 * write timeout is detected.
Willy Tarreauc9619462009-03-09 22:40:57 +01001113 */
1114 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1115 }
1116 }
1117
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001118 /* in case of special condition (error, shutdown, end of write...), we
1119 * have to notify the task.
1120 */
1121 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001122 ((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001123 si->state != SI_ST_EST)) {
1124 out_wakeup:
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001125 if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
1126 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001127 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001128}
1129
Willy Tarreaueb472682010-05-28 18:46:57 +02001130/* This function is called on a read event from a listening socket, corresponding
1131 * to an accept. It tries to accept as many connections as possible, and for each
1132 * calls the listener's accept handler (generally the frontend's accept handler).
1133 */
1134int stream_sock_accept(int fd)
1135{
1136 struct listener *l = fdtab[fd].owner;
1137 struct proxy *p = l->frontend;
1138 int max_accept = global.tune.maxaccept;
1139 int cfd;
1140 int ret;
1141
1142 if (unlikely(l->nbconn >= l->maxconn)) {
1143 EV_FD_CLR(l->fd, DIR_RD);
1144 l->state = LI_FULL;
1145 return 0;
1146 }
1147
1148 if (p && p->fe_sps_lim) {
1149 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
1150 if (max_accept > max)
1151 max_accept = max;
1152 }
1153
1154 while ((!p || p->feconn < p->maxconn) && actconn < global.maxconn && max_accept--) {
1155 struct sockaddr_storage addr;
1156 socklen_t laddr = sizeof(addr);
1157
1158 cfd = accept(fd, (struct sockaddr *)&addr, &laddr);
1159 if (unlikely(cfd == -1)) {
1160 switch (errno) {
1161 case EAGAIN:
1162 case EINTR:
1163 case ECONNABORTED:
1164 return 0; /* nothing more to accept */
1165 case ENFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001166 if (p)
1167 send_log(p, LOG_EMERG,
1168 "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
1169 p->id, maxfd);
Willy Tarreaueb472682010-05-28 18:46:57 +02001170 return 0;
1171 case EMFILE:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001172 if (p)
1173 send_log(p, LOG_EMERG,
1174 "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
1175 p->id, maxfd);
Willy Tarreaueb472682010-05-28 18:46:57 +02001176 return 0;
1177 case ENOBUFS:
1178 case ENOMEM:
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001179 if (p)
1180 send_log(p, LOG_EMERG,
1181 "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
1182 p->id, maxfd);
Willy Tarreaueb472682010-05-28 18:46:57 +02001183 return 0;
1184 default:
1185 return 0;
1186 }
1187 }
1188
1189 if (unlikely(cfd >= global.maxsock)) {
1190 Alert("accept(): not enough free sockets. Raise -n argument. Giving up.\n");
1191 goto out_close;
1192 }
1193
Willy Tarreau24dcaf32010-06-05 10:49:41 +02001194 actconn++;
1195 totalconn++;
1196 l->nbconn++;
1197
1198 if (l->counters) {
1199 if (l->nbconn > l->counters->conn_max)
1200 l->counters->conn_max = l->nbconn;
1201 }
1202
Willy Tarreaueb472682010-05-28 18:46:57 +02001203 ret = l->accept(l, cfd, &addr);
1204 if (unlikely(ret < 0)) {
1205 /* critical error encountered, generally a resource shortage */
Willy Tarreau7999ddb2010-06-04 20:46:13 +02001206 if (p) {
1207 EV_FD_CLR(fd, DIR_RD);
1208 p->state = PR_STIDLE;
1209 }
Willy Tarreau24dcaf32010-06-05 10:49:41 +02001210 actconn--;
1211 l->nbconn--;
Willy Tarreaueb472682010-05-28 18:46:57 +02001212 goto out_close;
1213 }
1214 else if (unlikely(ret == 0)) {
1215 /* ignore this connection */
Willy Tarreau24dcaf32010-06-05 10:49:41 +02001216 actconn--;
1217 l->nbconn--;
Willy Tarreaueb472682010-05-28 18:46:57 +02001218 close(cfd);
1219 continue;
1220 }
1221
Willy Tarreaueb472682010-05-28 18:46:57 +02001222 if (l->nbconn >= l->maxconn) {
1223 EV_FD_CLR(l->fd, DIR_RD);
1224 l->state = LI_FULL;
1225 }
Willy Tarreaueb472682010-05-28 18:46:57 +02001226 } /* end of while (p->feconn < p->maxconn) */
1227 return 0;
1228
1229 /* Error unrolling */
1230 out_close:
1231 close(cfd);
1232 return 0;
1233}
1234
Willy Tarreaua8f55d52010-05-31 17:44:19 +02001235/* Prepare a stream interface to be used in socket mode. */
1236void stream_sock_prepare_interface(struct stream_interface *si)
1237{
1238 si->update = stream_sock_data_finish;
1239 si->shutr = stream_sock_shutr;
1240 si->shutw = stream_sock_shutw;
1241 si->chk_rcv = stream_sock_chk_rcv;
1242 si->chk_snd = stream_sock_chk_snd;
1243 si->iohandler = NULL;
1244}
1245
Willy Tarreaubaaee002006-06-26 02:48:02 +02001246
1247/*
1248 * Local variables:
1249 * c-indent-level: 8
1250 * c-basic-offset: 8
1251 * End:
1252 */