blob: eb2bfbdcc9f4551c2fdfcfc9a44c8a95824d7a42 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreaub277d6e2012-05-11 16:59:14 +02002 * Functions used to send/receive data using SOCK_STREAM sockets.
Willy Tarreaubaaee002006-06-26 02:48:02 +02003 *
Willy Tarreaub277d6e2012-05-11 16:59:14 +02004 * Copyright 2000-2012 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 Tarreau8b117082012-08-06 15:06:49 +020033#include <proto/connection.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <proto/fd.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020035#include <proto/freq_ctr.h>
36#include <proto/log.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010037#include <proto/pipe.h>
Willy Tarreaufe598a72010-09-21 21:48:23 +020038#include <proto/protocols.h>
Willy Tarreauc63190d2012-05-11 14:23:52 +020039#include <proto/sock_raw.h>
Willy Tarreau73b013b2012-05-21 16:31:45 +020040#include <proto/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020041#include <proto/task.h>
42
Willy Tarreau5bd8c372009-01-19 00:32:22 +010043#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020044
Willy Tarreaub277d6e2012-05-11 16:59:14 +020045/* main event functions used to move data between sockets and buffers */
Willy Tarreau239d7182012-07-23 18:53:03 +020046static int sock_raw_read(struct connection *conn);
47static int sock_raw_write(struct connection *conn);
Willy Tarreaub277d6e2012-05-11 16:59:14 +020048static void sock_raw_data_finish(struct stream_interface *si);
Willy Tarreau3d8903f2012-08-06 17:00:18 +020049static void sock_raw_read0(struct stream_interface *si);
Willy Tarreaub277d6e2012-05-11 16:59:14 +020050static void sock_raw_chk_rcv(struct stream_interface *si);
51static void sock_raw_chk_snd(struct stream_interface *si);
52
53
Willy Tarreau6b4aad42009-01-18 21:59:13 +010054#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau43d8fb22011-08-22 17:12:02 +020055#include <common/splice.h>
Willy Tarreau5bd8c372009-01-19 00:32:22 +010056
57/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
58 * because of timestamps. Use this as a hint for not looping on splice().
59 */
60#define SPLICE_FULL_HINT 16*1448
61
Willy Tarreaua9de3332009-11-28 07:47:10 +010062/* how many data we attempt to splice at once when the buffer is configured for
63 * infinite forwarding */
64#define MAX_SPLICE_AT_ONCE (1<<30)
65
Willy Tarreau5bd8c372009-01-19 00:32:22 +010066/* Returns :
67 * -1 if splice is not possible or not possible anymore and we must switch to
68 * user-land copy (eg: to_forward reached)
69 * 0 when we know that polling is required to get more data (EAGAIN)
70 * 1 for all other cases (we can safely try again, or if an activity has been
71 * detected (DATA/NULL/ERR))
72 * Sets :
73 * BF_READ_NULL
74 * BF_READ_PARTIAL
75 * BF_WRITE_PARTIAL (during copy)
Willy Tarreauba0b63d2009-09-20 08:09:44 +020076 * BF_OUT_EMPTY (during copy)
Willy Tarreau5bd8c372009-01-19 00:32:22 +010077 * SI_FL_ERR
78 * SI_FL_WAIT_ROOM
79 * (SI_FL_WAIT_RECV)
Willy Tarreau3eba98a2009-01-25 13:56:13 +010080 *
81 * This function automatically allocates a pipe from the pipe pool. It also
82 * carefully ensures to clear b->pipe whenever it leaves the pipe empty.
Willy Tarreau5bd8c372009-01-19 00:32:22 +010083 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +020084static int sock_raw_splice_in(struct buffer *b, struct stream_interface *si)
Willy Tarreau5bd8c372009-01-19 00:32:22 +010085{
Willy Tarreau82a04562011-12-11 22:37:06 +010086 static int splice_detects_close;
Willy Tarreaufb7508a2012-05-21 16:47:54 +020087 int fd = si_fd(si);
Willy Tarreau31971e52009-09-20 12:07:52 +020088 int ret;
89 unsigned long max;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010090 int retval = 1;
91
92 if (!b->to_forward)
93 return -1;
94
95 if (!(b->flags & BF_KERN_SPLICING))
96 return -1;
97
Willy Tarreau02d6cfc2012-03-01 18:19:58 +010098 if (buffer_not_empty(b)) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +010099 /* We're embarrassed, there are already data pending in
100 * the buffer and we don't want to have them at two
101 * locations at a time. Let's indicate we need some
102 * place and ask the consumer to hurry.
103 */
104 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200105 fd_stop_recv(fd);
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100106 b->rex = TICK_ETERNITY;
Willy Tarreau73b013b2012-05-21 16:31:45 +0200107 si_chk_snd(b->cons);
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100108 return 1;
109 }
110
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100111 if (unlikely(b->pipe == NULL)) {
112 if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100113 b->flags &= ~BF_KERN_SPLICING;
114 return -1;
115 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100116 }
117
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100118 /* At this point, b->pipe is valid */
119
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100120 while (1) {
Willy Tarreaua9de3332009-11-28 07:47:10 +0100121 if (b->to_forward == BUF_INFINITE_FORWARD)
122 max = MAX_SPLICE_AT_ONCE;
123 else
124 max = b->to_forward;
125
Willy Tarreau31971e52009-09-20 12:07:52 +0200126 if (!max) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100127 /* It looks like the buffer + the pipe already contain
128 * the maximum amount of data to be transferred. Try to
129 * send those data immediately on the other side if it
130 * is currently waiting.
131 */
132 retval = -1; /* end of forwarding */
133 break;
134 }
135
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100136 ret = splice(fd, NULL, b->pipe->prod, NULL, max,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100137 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
138
139 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100140 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100141 /* connection closed. This is only detected by
Willy Tarreau82a04562011-12-11 22:37:06 +0100142 * recent kernels (>= 2.6.27.13). If we notice
143 * it works, we store the info for later use.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100144 */
Willy Tarreau82a04562011-12-11 22:37:06 +0100145 splice_detects_close = 1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100146 b->flags |= BF_READ_NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100147 retval = 1; /* no need for further polling */
148 break;
149 }
150
151 if (errno == EAGAIN) {
152 /* there are two reasons for EAGAIN :
153 * - nothing in the socket buffer (standard)
154 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100155 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100156 * Since we don't know if pipe is full, we'll
157 * stop if the pipe is not empty. Anyway, we
158 * will almost always fill/empty the pipe.
159 */
160
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100161 if (b->pipe->data) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100162 si->flags |= SI_FL_WAIT_ROOM;
163 retval = 1;
164 break;
165 }
166
Willy Tarreau82a04562011-12-11 22:37:06 +0100167 /* We don't know if the connection was closed,
168 * but if we know splice detects close, then we
169 * know it for sure.
Willy Tarreau98b306b2009-01-25 11:11:32 +0100170 * But if we're called upon POLLIN with an empty
Willy Tarreau82a04562011-12-11 22:37:06 +0100171 * pipe and get EAGAIN, it is suspect enough to
Willy Tarreau98b306b2009-01-25 11:11:32 +0100172 * try to fall back to the normal recv scheme
173 * which will be able to deal with the situation.
174 */
Willy Tarreau82a04562011-12-11 22:37:06 +0100175 if (splice_detects_close)
176 retval = 0; /* we know for sure that it's EAGAIN */
177 else
178 retval = -1;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100179 break;
180 }
Willy Tarreaudc340a92009-06-28 23:10:19 +0200181
Willy Tarreaua9de3332009-11-28 07:47:10 +0100182 if (errno == ENOSYS || errno == EINVAL) {
Willy Tarreaudc340a92009-06-28 23:10:19 +0200183 /* splice not supported on this end, disable it */
184 b->flags &= ~BF_KERN_SPLICING;
185 si->flags &= ~SI_FL_CAP_SPLICE;
186 put_pipe(b->pipe);
187 b->pipe = NULL;
188 return -1;
189 }
190
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100191 /* here we have another error */
192 si->flags |= SI_FL_ERR;
193 retval = 1;
194 break;
195 } /* ret <= 0 */
196
Willy Tarreau31971e52009-09-20 12:07:52 +0200197 if (b->to_forward != BUF_INFINITE_FORWARD)
198 b->to_forward -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100199 b->total += ret;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100200 b->pipe->data += ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100201 b->flags |= BF_READ_PARTIAL;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200202 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100203
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100204 if (b->pipe->data >= SPLICE_FULL_HINT ||
205 ret >= global.tune.recv_enough) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100206 /* We've read enough of it for this time. */
207 retval = 1;
208 break;
209 }
210 } /* while */
211
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100212 if (unlikely(!b->pipe->data)) {
213 put_pipe(b->pipe);
214 b->pipe = NULL;
215 }
216
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100217 return retval;
218}
219
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100220#endif /* CONFIG_HAP_LINUX_SPLICE */
221
222
Willy Tarreaubaaee002006-06-26 02:48:02 +0200223/*
Willy Tarreaud7971282006-07-29 18:36:34 +0200224 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200225 * It returns 0 if we have a high confidence that we will not be
226 * able to read more data without polling first. Returns non-zero
227 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200228 */
Willy Tarreau239d7182012-07-23 18:53:03 +0200229static int sock_raw_read(struct connection *conn)
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200230{
Willy Tarreau239d7182012-07-23 18:53:03 +0200231 int fd = conn->t.sock.fd;
Willy Tarreau80184712012-07-06 14:54:49 +0200232 struct stream_interface *si = container_of(conn, struct stream_interface, conn);
Willy Tarreau48adac52008-08-30 04:58:38 +0200233 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200234 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100235 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200236
237#ifdef DEBUG_FULL
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200238 fprintf(stderr,"sock_raw_read : fd=%d, ev=0x%02x, owner=%p\n", fd, fdtab[fd].ev, fdtab[fd].owner);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200239#endif
240
Willy Tarreau83749182007-04-15 20:56:27 +0200241 retval = 1;
242
Willy Tarreau71543652009-07-14 19:55:05 +0200243 /* stop immediately on errors. Note that we DON'T want to stop on
244 * POLL_ERR, as the poller might report a write error while there
245 * are still data available in the recv buffer. This typically
246 * happens when we send too large a request to a backend server
247 * which rejects it before reading it all.
248 */
Willy Tarreau80184712012-07-06 14:54:49 +0200249 if (conn->flags & CO_FL_ERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200250 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100251
252 /* stop here if we reached the end of data */
253 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
254 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200255
Willy Tarreaud06e7112009-03-29 10:18:41 +0200256 /* maybe we were called immediately after an asynchronous shutr */
257 if (b->flags & BF_SHUTR)
258 goto out_wakeup;
259
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100260#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau14acc702011-05-11 20:47:24 +0200261 if (b->to_forward >= MIN_SPLICE_FORWARD && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100262
263 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
264 * Since older splice() implementations were buggy and returned
265 * EAGAIN on end of read, let's bypass the call to splice() now.
266 */
267 if (fdtab[fd].ev & FD_POLL_HUP)
268 goto out_shutdown_r;
269
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200270 retval = sock_raw_splice_in(b, si);
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100271
272 if (retval >= 0) {
273 if (si->flags & SI_FL_ERR)
274 goto out_error;
275 if (b->flags & BF_READ_NULL)
276 goto out_shutdown_r;
277 goto out_wakeup;
278 }
279 /* splice not possible (anymore), let's go on on standard copy */
280 }
281#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200282 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200283 while (1) {
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200284 max = bi_avail(b);
Willy Tarreau864e8252009-12-28 17:36:37 +0100285
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200286 if (!max) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100287 b->flags |= BF_FULL;
288 si->flags |= SI_FL_WAIT_ROOM;
289 break;
290 }
291
Willy Tarreau6996e152007-04-30 14:37:43 +0200292 /*
293 * 1. compute the maximum block size we can read at once.
294 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100295 if (buffer_empty(b)) {
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100296 /* let's realign the buffer to optimize I/O */
Willy Tarreaua458b672012-03-05 11:17:50 +0100297 b->p = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200298 }
Willy Tarreau89fa7062012-03-02 16:13:16 +0100299 else if (b->data + b->o < b->p &&
300 b->p + b->i < b->data + b->size) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100301 /* remaining space wraps at the end, with a moving limit */
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100302 if (max > b->data + b->size - (b->p + b->i))
303 max = b->data + b->size - (b->p + b->i);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100304 }
Willy Tarreau864e8252009-12-28 17:36:37 +0100305 /* else max is already OK */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200306
Willy Tarreau6996e152007-04-30 14:37:43 +0200307 /*
308 * 2. read the largest possible block
309 */
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200310 ret = recv(fd, bi_end(b), max, 0);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200311
Willy Tarreau83749182007-04-15 20:56:27 +0200312 if (ret > 0) {
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100313 b->i += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200314 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100315
Willy Tarreau2e046c62012-03-01 16:08:30 +0100316 /* if we're allowed to directly forward data, we must update ->o */
Willy Tarreau31971e52009-09-20 12:07:52 +0200317 if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
318 unsigned long fwd = ret;
319 if (b->to_forward != BUF_INFINITE_FORWARD) {
320 if (fwd > b->to_forward)
321 fwd = b->to_forward;
322 b->to_forward -= fwd;
323 }
Willy Tarreau328582c2012-05-05 23:32:27 +0200324 b_adv(b, fwd);
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100325 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100326
Willy Tarreau80184712012-07-06 14:54:49 +0200327 if (conn->flags & CO_FL_WAIT_L4_CONN) {
328 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200329 si->exp = TICK_ETERNITY;
330 }
Willy Tarreaub38903c2008-11-23 21:33:29 +0100331
Willy Tarreau3da77c52008-08-29 09:58:42 +0200332 b->flags |= BF_READ_PARTIAL;
Willy Tarreau83749182007-04-15 20:56:27 +0200333 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100334
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200335 if (bi_full(b)) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200336 /* The buffer is now full, there's no point in going through
337 * the loop again.
338 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100339 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == buffer_len(b))) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200340 b->xfer_small = 0;
341 b->xfer_large++;
342 if (b->xfer_large >= 3) {
343 /* we call this buffer a fast streamer if it manages
344 * to be filled in one call 3 consecutive times.
345 */
346 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
347 //fputc('+', stderr);
348 }
349 }
350 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200351 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200352 b->xfer_large = 0;
353 b->xfer_small++;
354 if (b->xfer_small >= 2) {
355 /* if the buffer has been at least half full twice,
356 * we receive faster than we send, so at least it
357 * is not a "fast streamer".
358 */
359 b->flags &= ~BF_STREAMER_FAST;
360 //fputc('-', stderr);
361 }
362 }
363 else {
364 b->xfer_small = 0;
365 b->xfer_large = 0;
366 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100367
368 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100369 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100370 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200371 }
372
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200373 /* if too many bytes were missing from last read, it means that
374 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100375 * not have them in buffers. BTW, if FD_POLL_HUP was present,
376 * it means that we have reached the end and that the connection
377 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200378 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100379 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200380 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200381 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200382 b->xfer_large = 0;
383 b->xfer_small++;
384 if (b->xfer_small >= 3) {
385 /* we have read less than half of the buffer in
386 * one pass, and this happened at least 3 times.
387 * This is definitely not a streamer.
388 */
389 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
390 //fputc('!', stderr);
391 }
392 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200393 /* unfortunately, on level-triggered events, POLL_HUP
394 * is generally delivered AFTER the system buffer is
395 * empty, so this one might never match.
396 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100397 if (fdtab[fd].ev & FD_POLL_HUP)
398 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200399
400 /* if a streamer has read few data, it may be because we
401 * have exhausted system buffers. It's not worth trying
402 * again.
403 */
404 if (b->flags & BF_STREAMER)
405 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200406
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100407 /* generally if we read something smaller than 1 or 2 MSS,
408 * it means that either we have exhausted the system's
409 * buffers (streamer or question-response protocol) or
410 * that the connection will be closed. Streamers are
411 * easily detected so we return early. For other cases,
412 * it's still better to perform a last read to be sure,
413 * because it may save one complete poll/read/wakeup cycle
414 * in case of shutdown.
415 */
416 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
417 break;
418
419 /* if we read a large block smaller than what we requested,
420 * it's almost certain we'll never get anything more.
421 */
422 if (ret >= global.tune.recv_enough)
423 break;
424 }
Willy Tarreau83749182007-04-15 20:56:27 +0200425
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100426 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200427 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200428 }
429 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200430 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100431 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200432 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200433 else if (errno == EAGAIN) {
434 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100435 * nothing to read left if we did not read much, ie
436 * less than what we were still expecting to read.
437 * But we may have done some work justifying to notify
438 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200439 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100440 if (cur_read < MIN_RET_FOR_READ_LOOP)
441 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200442 break;
443 }
444 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200445 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200446 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200447 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200448
Willy Tarreau6996e152007-04-30 14:37:43 +0200449 out_wakeup:
Willy Tarreau83749182007-04-15 20:56:27 +0200450 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200451
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100452 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200453 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100454 fdtab[fd].ev &= ~FD_POLL_HUP;
455 b->flags |= BF_READ_NULL;
Willy Tarreau520d95e2009-09-19 21:04:57 +0200456 if (b->flags & BF_AUTO_CLOSE)
Willy Tarreau418fd472009-09-06 21:37:23 +0200457 buffer_shutw_now(b);
Willy Tarreau3d8903f2012-08-06 17:00:18 +0200458 sock_raw_read0(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200459 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100460
Willy Tarreau6996e152007-04-30 14:37:43 +0200461 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100462 /* Read error on the file descriptor. We mark the FD as STERROR so
463 * that we don't use it anymore. The error is reported to the stream
464 * interface which will take proper action. We must not perturbate the
465 * buffer because the stream interface wants to ensure transparent
466 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200467 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100468
Willy Tarreau80184712012-07-06 14:54:49 +0200469 conn->flags |= CO_FL_ERROR;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200470 fd_stop_both(fd);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100471 retval = 1;
472 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200473}
474
475
476/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100477 * This function is called to send buffer data to a stream socket.
478 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100479 * before calling it again, otherwise 1. If a pipe was associated with the
480 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200481 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200482static int sock_raw_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100483{
Willy Tarreau83749182007-04-15 20:56:27 +0200484 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100485 int retval = 1;
486 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200487
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100488#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100489 while (b->pipe) {
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200490 ret = splice(b->pipe->cons, NULL, si_fd(si), NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100491 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
492 if (ret <= 0) {
493 if (ret == 0 || errno == EAGAIN) {
494 retval = 0;
495 return retval;
496 }
497 /* here we have another error */
498 retval = -1;
499 return retval;
500 }
501
502 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100503 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100504
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100505 if (!b->pipe->data) {
506 put_pipe(b->pipe);
507 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100508 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100509 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100510
511 if (--write_poll <= 0)
512 return retval;
Willy Tarreaueb9fd512011-12-11 22:11:47 +0100513
514 /* The only reason we did not empty the pipe is that the output
515 * buffer is full.
516 */
517 return 0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100518 }
519
520 /* At this point, the pipe is empty, but we may still have data pending
521 * in the normal buffer.
522 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100523#endif
Willy Tarreau2e046c62012-03-01 16:08:30 +0100524 if (!b->o) {
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200525 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100526 return retval;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200527 }
Willy Tarreau83749182007-04-15 20:56:27 +0200528
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100529 /* when we're in this loop, we already know that there is no spliced
530 * data left, and that there are sendable buffered data.
531 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200532 while (1) {
Willy Tarreau89fa7062012-03-02 16:13:16 +0100533 max = b->o;
Willy Tarreau83749182007-04-15 20:56:27 +0200534
Willy Tarreau89fa7062012-03-02 16:13:16 +0100535 /* outgoing data may wrap at the end */
536 if (b->data + max > b->p)
537 max = b->data + max - b->p;
Willy Tarreauf890dc92008-12-13 21:12:26 +0100538
Willy Tarreau6db06d32009-08-19 11:14:11 +0200539 /* check if we want to inform the kernel that we're interested in
540 * sending more data after this call. We want this if :
541 * - we're about to close after this last send and want to merge
542 * the ongoing FIN with the last segment.
543 * - we know we can't send everything at once and must get back
544 * here because of unaligned data
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100545 * - there is still a finite amount of data to forward
Willy Tarreau6db06d32009-08-19 11:14:11 +0200546 * The test is arranged so that the most common case does only 2
547 * tests.
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200548 */
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200549
Willy Tarreauface8392010-01-03 11:37:54 +0100550 if (MSG_NOSIGNAL && MSG_MORE) {
Willy Tarreau6db06d32009-08-19 11:14:11 +0200551 unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
552
Willy Tarreau96e31212011-05-30 18:10:30 +0200553 if ((!(b->flags & BF_NEVER_WAIT) &&
554 ((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
555 (b->flags & BF_EXPECT_MORE))) ||
Willy Tarreau2e046c62012-03-01 16:08:30 +0100556 ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->o)) ||
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100557 (max != b->o)) {
Willy Tarreauface8392010-01-03 11:37:54 +0100558 send_flag |= MSG_MORE;
559 }
Willy Tarreau6db06d32009-08-19 11:14:11 +0200560
Willy Tarreau2be39392010-01-03 17:24:51 +0100561 /* this flag has precedence over the rest */
562 if (b->flags & BF_SEND_DONTWAIT)
563 send_flag &= ~MSG_MORE;
564
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200565 ret = send(si_fd(si), bo_ptr(b), max, send_flag);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200566 } else {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200567 int skerr;
568 socklen_t lskerr = sizeof(skerr);
569
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200570 ret = getsockopt(si_fd(si), SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200571 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200572 ret = -1;
573 else
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200574 ret = send(si_fd(si), bo_ptr(b), max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200575 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200576
577 if (ret > 0) {
Willy Tarreau505e34a2012-07-06 10:17:53 +0200578 if (si->conn.flags & CO_FL_WAIT_L4_CONN) {
579 si->conn.flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200580 si->exp = TICK_ETERNITY;
581 }
Willy Tarreaub38903c2008-11-23 21:33:29 +0100582
Willy Tarreau3da77c52008-08-29 09:58:42 +0200583 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200584
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100585 b->o -= ret;
586 if (likely(!buffer_len(b)))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100587 /* optimize data alignment in the buffer */
Willy Tarreaua458b672012-03-05 11:17:50 +0100588 b->p = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200589
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200590 if (likely(!bi_full(b)))
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100591 b->flags &= ~BF_FULL;
592
Willy Tarreau2e046c62012-03-01 16:08:30 +0100593 if (!b->o) {
Willy Tarreauf17810e2012-03-09 18:10:44 +0100594 /* Always clear both flags once everything has been sent, they're one-shot */
595 b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT);
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200596 if (likely(!b->pipe))
597 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100598 break;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200599 }
Willy Tarreau83749182007-04-15 20:56:27 +0200600
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200601 /* if the system buffer is full, don't insist */
602 if (ret < max)
603 break;
604
Willy Tarreau6996e152007-04-30 14:37:43 +0200605 if (--write_poll <= 0)
606 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200607 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200608 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100609 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200610 retval = 0;
611 break;
612 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200613 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100614 /* bad, we got an error */
615 retval = -1;
616 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200617 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200618 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200619
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100620 return retval;
621}
Willy Tarreau6996e152007-04-30 14:37:43 +0200622
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100623
624/*
625 * This function is called on a write event from a stream socket.
626 * It returns 0 if the caller needs to poll before calling it again, otherwise
627 * non-zero.
628 */
Willy Tarreau239d7182012-07-23 18:53:03 +0200629static int sock_raw_write(struct connection *conn)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100630{
Willy Tarreau239d7182012-07-23 18:53:03 +0200631 int fd = conn->t.sock.fd;
Willy Tarreau80184712012-07-06 14:54:49 +0200632 struct stream_interface *si = container_of(conn, struct stream_interface, conn);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100633 struct buffer *b = si->ob;
634 int retval = 1;
635
636#ifdef DEBUG_FULL
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200637 fprintf(stderr,"sock_raw_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100638#endif
639
Willy Tarreau80184712012-07-06 14:54:49 +0200640 if (conn->flags & CO_FL_ERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100641 goto out_error;
642
Willy Tarreaud06e7112009-03-29 10:18:41 +0200643 /* we might have been called just after an asynchronous shutw */
644 if (b->flags & BF_SHUTW)
645 goto out_wakeup;
646
Willy Tarreaueeda90e2012-05-11 19:53:32 +0200647 retval = sock_raw_write_loop(si, b);
648 if (retval < 0)
649 goto out_error;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100650
Willy Tarreaufd31e532012-07-23 18:24:25 +0200651 out_wakeup:
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100652 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100653
Willy Tarreau6996e152007-04-30 14:37:43 +0200654 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100655 /* Write error on the file descriptor. We mark the FD as STERROR so
656 * that we don't use it anymore. The error is reported to the stream
657 * interface which will take proper action. We must not perturbate the
658 * buffer because the stream interface wants to ensure transparent
659 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200660 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100661
Willy Tarreau80184712012-07-06 14:54:49 +0200662 conn->flags |= CO_FL_ERROR;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200663 fd_stop_both(fd);
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200664 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200665}
666
Willy Tarreau48adac52008-08-30 04:58:38 +0200667/*
Willy Tarreau3d8903f2012-08-06 17:00:18 +0200668 * This function propagates a null read received on a connection. It updates
669 * the stream interface. If the stream interface has SI_FL_NOHALF, we also
670 * forward the close to the write side.
671 */
672static void sock_raw_read0(struct stream_interface *si)
673{
674 si->ib->flags &= ~BF_SHUTR_NOW;
675 if (si->ib->flags & BF_SHUTR)
676 return;
677 si->ib->flags |= BF_SHUTR;
678 si->ib->rex = TICK_ETERNITY;
679 si->flags &= ~SI_FL_WAIT_ROOM;
680
681 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
682 return;
683
684 if (si->ob->flags & BF_SHUTW)
685 goto do_close;
686
687 if (si->flags & SI_FL_NOHALF) {
688 /* we have to shut before closing, otherwise some short messages
689 * may never leave the system, especially when there are remaining
690 * unread data in the socket input buffer, or when nolinger is set.
691 * However, if SI_FL_NOLINGER is explicitly set, we know there is
692 * no risk so we close both sides immediately.
693 */
694 if (si->flags & SI_FL_NOLINGER) {
695 si->flags &= ~SI_FL_NOLINGER;
696 setsockopt(si_fd(si), SOL_SOCKET, SO_LINGER,
697 (struct linger *) &nolinger, sizeof(struct linger));
698 }
699 goto do_close;
700 }
701
702 /* otherwise that's just a normal read shutdown */
Willy Tarreau49b046d2012-08-09 12:11:58 +0200703 fd_stop_recv(si_fd(si));
Willy Tarreau3d8903f2012-08-06 17:00:18 +0200704 return;
705
706 do_close:
707 conn_data_close(&si->conn);
708 fd_delete(si_fd(si));
709 si->state = SI_ST_DIS;
710 si->exp = TICK_ETERNITY;
711 if (si->release)
712 si->release(si);
713 return;
714}
715
716/*
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200717 * Updates a connected sock_raw file descriptor status and timeouts
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200718 * according to the buffers' flags. It should only be called once after the
719 * buffer flags have settled down, and before they are cleared. It doesn't
720 * harm to call it as often as desired (it just slightly hurts performance).
721 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200722static void sock_raw_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200723{
Willy Tarreaub0253252008-11-30 21:37:12 +0100724 struct buffer *ib = si->ib;
725 struct buffer *ob = si->ob;
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200726 int fd = si_fd(si);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200727
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100728 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200729 now_ms, __FUNCTION__,
730 fd, fdtab[fd].owner,
731 ib, ob,
732 ib->rex, ob->wex,
733 ib->flags, ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100734 ib->i, ib->o, ob->i, ob->o, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200735
736 /* Check if we need to close the read side */
737 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200738 /* Read not closed, update FD status and timeout for reads */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200739 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200740 /* stop reading */
Willy Tarreau11f49402010-11-11 23:08:17 +0100741 if (!(si->flags & SI_FL_WAIT_ROOM)) {
742 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
743 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200744 fd_stop_recv(fd);
Willy Tarreau11f49402010-11-11 23:08:17 +0100745 ib->rex = TICK_ETERNITY;
746 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200747 }
748 else {
749 /* (re)start reading and update timeout. Note: we don't recompute the timeout
750 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200751 * update it if is was not yet set. The stream socket handler will already
752 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200753 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100754 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200755 fd_want_recv(fd);
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200756 if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
Willy Tarreau2d212792008-08-27 21:41:35 +0200757 ib->rex = tick_add_ifset(now_ms, ib->rto);
758 }
759 }
760
761 /* Check if we need to close the write side */
762 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200763 /* Write not closed, update FD status and timeout for writes */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200764 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200765 /* stop writing */
Willy Tarreau11f49402010-11-11 23:08:17 +0100766 if (!(si->flags & SI_FL_WAIT_DATA)) {
767 if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
768 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200769 fd_stop_send(fd);
Willy Tarreau11f49402010-11-11 23:08:17 +0100770 ob->wex = TICK_ETERNITY;
771 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200772 }
773 else {
774 /* (re)start writing and update timeout. Note: we don't recompute the timeout
775 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200776 * update it if is was not yet set. The stream socket handler will already
777 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200778 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100779 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200780 fd_want_send(fd);
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200781 if (!tick_isset(ob->wex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200782 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200783 if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200784 /* Note: depending on the protocol, we don't know if we're waiting
785 * for incoming data or not. So in order to prevent the socket from
786 * expiring read timeouts during writes, we refresh the read timeout,
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200787 * except if it was already infinite or if we have explicitly setup
Jamie Gloudon801a0a32012-08-25 00:18:33 -0400788 * independent streams.
Willy Tarreau2d212792008-08-27 21:41:35 +0200789 */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200790 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +0200791 }
792 }
793 }
794 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200795}
796
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100797/* This function is used for inter-stream-interface calls. It is called by the
798 * consumer to inform the producer side that it may be interested in checking
799 * for free space in the buffer. Note that it intentionally does not update
800 * timeouts, so that we can still check them later at wake-up.
801 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200802static void sock_raw_chk_rcv(struct stream_interface *si)
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100803{
804 struct buffer *ib = si->ib;
805
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100806 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100807 now_ms, __FUNCTION__,
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200808 si_fd(si), fdtab[si_fd(si)].owner,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +0000809 ib, si->ob,
810 ib->rex, si->ob->wex,
811 ib->flags, si->ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100812 ib->i, ib->o, si->ob->i, si->ob->o, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100813
814 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
815 return;
816
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200817 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100818 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200819 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100820 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200821 fd_stop_recv(si_fd(si));
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100822 }
823 else {
824 /* (re)start reading */
825 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200826 fd_want_recv(si_fd(si));
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100827 }
828}
829
830
831/* This function is used for inter-stream-interface calls. It is called by the
832 * producer to inform the consumer side that it may be interested in checking
833 * for data in the buffer. Note that it intentionally does not update timeouts,
834 * so that we can still check them later at wake-up.
835 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200836static void sock_raw_chk_snd(struct stream_interface *si)
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100837{
838 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100839 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100840
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100841 DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100842 now_ms, __FUNCTION__,
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200843 si_fd(si), fdtab[si_fd(si)].owner,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +0000844 si->ib, ob,
845 si->ib->rex, ob->wex,
846 si->ib->flags, ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100847 si->ib->i, si->ib->o, ob->i, ob->o, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100848
849 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
850 return;
851
Willy Tarreaua190d592012-05-20 18:35:19 +0200852 if (unlikely(ob->flags & BF_OUT_EMPTY)) /* called with nothing to send ! */
Willy Tarreaueb9fd512011-12-11 22:11:47 +0100853 return;
854
855 if (!ob->pipe && /* spliced data wants to be forwarded ASAP */
856 (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200857 (fdtab[si_fd(si)].ev & FD_POLL_OUT))) /* we'll be called anyway */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100858 return;
859
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200860 retval = sock_raw_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +0200861 /* here, we have :
862 * retval < 0 if an error was encountered during write.
863 * retval = 0 if we can't write anymore without polling
864 * retval = 1 if we're invited to come back when desired
865 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100866 if (retval < 0) {
867 /* Write error on the file descriptor. We mark the FD as STERROR so
868 * that we don't use it anymore and we notify the task.
869 */
Willy Tarreau505e34a2012-07-06 10:17:53 +0200870 si->conn.flags |= CO_FL_ERROR;
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200871 fdtab[si_fd(si)].ev &= ~FD_POLL_STICKY;
Willy Tarreau49b046d2012-08-09 12:11:58 +0200872 fd_stop_both(si_fd(si));
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100873 si->flags |= SI_FL_ERR;
874 goto out_wakeup;
875 }
876
Willy Tarreauc54aef32009-07-27 20:08:06 +0200877 /* OK, so now we know that retval >= 0 means that some data might have
878 * been sent, and that we may have to poll first. We have to do that
879 * too if the buffer is not empty.
880 */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200881 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100882 /* the connection is established but we can't write. Either the
883 * buffer is empty, or we just refrain from sending because the
Willy Tarreau2e046c62012-03-01 16:08:30 +0100884 * ->o limit was reached. Maybe we just wrote the last
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100885 * chunk and need to close.
886 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200887 if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
888 (BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100889 (si->state == SI_ST_EST)) {
Willy Tarreau4a36b562012-08-06 19:31:45 +0200890 si_shutw(si);
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100891 goto out_wakeup;
892 }
Willy Tarreaud06e7112009-03-29 10:18:41 +0200893
Willy Tarreau59454bf2009-09-20 11:13:40 +0200894 if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100895 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100896 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100897 }
898 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +0200899 /* Otherwise there are remaining data to be sent in the buffer,
900 * which means we have to poll before doing so.
901 */
Willy Tarreau49b046d2012-08-09 12:11:58 +0200902 fd_want_send(si_fd(si));
Willy Tarreauc54aef32009-07-27 20:08:06 +0200903 si->flags &= ~SI_FL_WAIT_DATA;
904 if (!tick_isset(ob->wex))
905 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100906 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100907
Willy Tarreauc9619462009-03-09 22:40:57 +0100908 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
909 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200910 if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreauc9619462009-03-09 22:40:57 +0100911 ob->wex = tick_add_ifset(now_ms, ob->wto);
912
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200913 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreauc9619462009-03-09 22:40:57 +0100914 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200915 * during writes, we refresh it. We only do this if the
Jamie Gloudon801a0a32012-08-25 00:18:33 -0400916 * interface is not configured for "independent streams",
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200917 * because for some applications it's better not to do this,
918 * for instance when continuously exchanging small amounts
919 * of data which can full the socket buffers long before a
920 * write timeout is detected.
Willy Tarreauc9619462009-03-09 22:40:57 +0100921 */
922 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
923 }
924 }
925
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100926 /* in case of special condition (error, shutdown, end of write...), we
927 * have to notify the task.
928 */
929 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200930 ((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100931 si->state != SI_ST_EST)) {
932 out_wakeup:
Willy Tarreau89f7ef22009-09-05 20:57:35 +0200933 if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
934 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100935 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100936}
937
Willy Tarreau5c979a92012-05-07 17:15:39 +0200938/* stream sock operations */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200939struct sock_ops sock_raw = {
940 .update = sock_raw_data_finish,
Willy Tarreau4a36b562012-08-06 19:31:45 +0200941 .shutr = NULL,
942 .shutw = NULL,
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200943 .chk_rcv = sock_raw_chk_rcv,
944 .chk_snd = sock_raw_chk_snd,
945 .read = sock_raw_read,
946 .write = sock_raw_write,
Willy Tarreau24208272012-05-21 17:28:50 +0200947 .close = NULL,
Willy Tarreau5c979a92012-05-07 17:15:39 +0200948};
Willy Tarreaubaaee002006-06-26 02:48:02 +0200949
950/*
951 * Local variables:
952 * c-indent-level: 8
953 * c-basic-offset: 8
954 * End:
955 */