blob: 37524be6d777c9463eac20a452dd4b5aa70b6269 [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 Tarreaubaaee002006-06-26 02:48:02 +020033#include <proto/fd.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020034#include <proto/freq_ctr.h>
Willy Tarreaub22e55b2011-03-20 10:16:46 +010035#include <proto/frontend.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020036#include <proto/log.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010037#include <proto/pipe.h>
Willy Tarreaufe598a72010-09-21 21:48:23 +020038#include <proto/protocols.h>
Willy Tarreauc63190d2012-05-11 14:23:52 +020039#include <proto/sock_raw.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040#include <proto/task.h>
41
Willy Tarreau5bd8c372009-01-19 00:32:22 +010042#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020043
Willy Tarreaub277d6e2012-05-11 16:59:14 +020044/* main event functions used to move data between sockets and buffers */
45static int sock_raw_read(int fd);
46static int sock_raw_write(int fd);
47static void sock_raw_data_finish(struct stream_interface *si);
48static void sock_raw_shutr(struct stream_interface *si);
49static void sock_raw_shutw(struct stream_interface *si);
50static 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 Tarreau5bd8c372009-01-19 00:32:22 +010087 int fd = si->fd;
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;
105 EV_FD_CLR(fd, DIR_RD);
106 b->rex = TICK_ETERNITY;
Willy Tarreau060781f2012-05-07 16:50:03 +0200107 b->cons->sock.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 Tarreaub277d6e2012-05-11 16:59:14 +0200229static int sock_raw_read(int fd)
230{
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200231 struct stream_interface *si = fdtab[fd].owner;
Willy Tarreau48adac52008-08-30 04:58:38 +0200232 struct buffer *b = si->ib;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200233 int ret, max, retval, cur_read;
Willy Tarreaub8949f12007-03-23 22:39:59 +0100234 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200235
236#ifdef DEBUG_FULL
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200237 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 +0200238#endif
239
Willy Tarreau83749182007-04-15 20:56:27 +0200240 retval = 1;
241
Willy Tarreau71543652009-07-14 19:55:05 +0200242 /* stop immediately on errors. Note that we DON'T want to stop on
243 * POLL_ERR, as the poller might report a write error while there
244 * are still data available in the recv buffer. This typically
245 * happens when we send too large a request to a backend server
246 * which rejects it before reading it all.
247 */
248 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau6996e152007-04-30 14:37:43 +0200249 goto out_error;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100250
251 /* stop here if we reached the end of data */
252 if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP)
253 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200254
Willy Tarreaud06e7112009-03-29 10:18:41 +0200255 /* maybe we were called immediately after an asynchronous shutr */
256 if (b->flags & BF_SHUTR)
257 goto out_wakeup;
258
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100259#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau14acc702011-05-11 20:47:24 +0200260 if (b->to_forward >= MIN_SPLICE_FORWARD && b->flags & BF_KERN_SPLICING) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100261
262 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
263 * Since older splice() implementations were buggy and returned
264 * EAGAIN on end of read, let's bypass the call to splice() now.
265 */
266 if (fdtab[fd].ev & FD_POLL_HUP)
267 goto out_shutdown_r;
268
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200269 retval = sock_raw_splice_in(b, si);
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100270
271 if (retval >= 0) {
272 if (si->flags & SI_FL_ERR)
273 goto out_error;
274 if (b->flags & BF_READ_NULL)
275 goto out_shutdown_r;
276 goto out_wakeup;
277 }
278 /* splice not possible (anymore), let's go on on standard copy */
279 }
280#endif
Willy Tarreau8a7af602008-05-03 23:07:14 +0200281 cur_read = 0;
Willy Tarreau6996e152007-04-30 14:37:43 +0200282 while (1) {
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200283 max = bi_avail(b);
Willy Tarreau864e8252009-12-28 17:36:37 +0100284
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200285 if (!max) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100286 b->flags |= BF_FULL;
287 si->flags |= SI_FL_WAIT_ROOM;
288 break;
289 }
290
Willy Tarreau6996e152007-04-30 14:37:43 +0200291 /*
292 * 1. compute the maximum block size we can read at once.
293 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100294 if (buffer_empty(b)) {
Willy Tarreau03d60bb2009-01-09 11:13:00 +0100295 /* let's realign the buffer to optimize I/O */
Willy Tarreaua458b672012-03-05 11:17:50 +0100296 b->p = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200297 }
Willy Tarreau89fa7062012-03-02 16:13:16 +0100298 else if (b->data + b->o < b->p &&
299 b->p + b->i < b->data + b->size) {
Willy Tarreau864e8252009-12-28 17:36:37 +0100300 /* remaining space wraps at the end, with a moving limit */
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100301 if (max > b->data + b->size - (b->p + b->i))
302 max = b->data + b->size - (b->p + b->i);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100303 }
Willy Tarreau864e8252009-12-28 17:36:37 +0100304 /* else max is already OK */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200305
Willy Tarreau6996e152007-04-30 14:37:43 +0200306 /*
307 * 2. read the largest possible block
308 */
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200309 ret = recv(fd, bi_end(b), max, 0);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200310
Willy Tarreau83749182007-04-15 20:56:27 +0200311 if (ret > 0) {
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100312 b->i += ret;
Willy Tarreau8a7af602008-05-03 23:07:14 +0200313 cur_read += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100314
Willy Tarreau2e046c62012-03-01 16:08:30 +0100315 /* if we're allowed to directly forward data, we must update ->o */
Willy Tarreau31971e52009-09-20 12:07:52 +0200316 if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
317 unsigned long fwd = ret;
318 if (b->to_forward != BUF_INFINITE_FORWARD) {
319 if (fwd > b->to_forward)
320 fwd = b->to_forward;
321 b->to_forward -= fwd;
322 }
Willy Tarreau328582c2012-05-05 23:32:27 +0200323 b_adv(b, fwd);
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100324 }
Willy Tarreauf890dc92008-12-13 21:12:26 +0100325
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200326 if (fdtab[fd].state == FD_STCONN) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100327 fdtab[fd].state = FD_STREADY;
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200328 si->exp = TICK_ETERNITY;
329 }
Willy Tarreaub38903c2008-11-23 21:33:29 +0100330
Willy Tarreau3da77c52008-08-29 09:58:42 +0200331 b->flags |= BF_READ_PARTIAL;
Willy Tarreau83749182007-04-15 20:56:27 +0200332 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100333
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200334 if (bi_full(b)) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200335 /* The buffer is now full, there's no point in going through
336 * the loop again.
337 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100338 if (!(b->flags & BF_STREAMER_FAST) && (cur_read == buffer_len(b))) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200339 b->xfer_small = 0;
340 b->xfer_large++;
341 if (b->xfer_large >= 3) {
342 /* we call this buffer a fast streamer if it manages
343 * to be filled in one call 3 consecutive times.
344 */
345 b->flags |= (BF_STREAMER | BF_STREAMER_FAST);
346 //fputc('+', stderr);
347 }
348 }
349 else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200350 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200351 b->xfer_large = 0;
352 b->xfer_small++;
353 if (b->xfer_small >= 2) {
354 /* if the buffer has been at least half full twice,
355 * we receive faster than we send, so at least it
356 * is not a "fast streamer".
357 */
358 b->flags &= ~BF_STREAMER_FAST;
359 //fputc('-', stderr);
360 }
361 }
362 else {
363 b->xfer_small = 0;
364 b->xfer_large = 0;
365 }
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100366
367 b->flags |= BF_FULL;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100368 si->flags |= SI_FL_WAIT_ROOM;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100369 break;
Willy Tarreau6996e152007-04-30 14:37:43 +0200370 }
371
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200372 /* if too many bytes were missing from last read, it means that
373 * it's pointless trying to read again because the system does
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100374 * not have them in buffers. BTW, if FD_POLL_HUP was present,
375 * it means that we have reached the end and that the connection
376 * is closed.
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200377 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100378 if (ret < max) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200379 if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) &&
Willy Tarreaua07a34e2009-08-16 23:27:46 +0200380 (cur_read <= b->size / 2)) {
Willy Tarreau8a7af602008-05-03 23:07:14 +0200381 b->xfer_large = 0;
382 b->xfer_small++;
383 if (b->xfer_small >= 3) {
384 /* we have read less than half of the buffer in
385 * one pass, and this happened at least 3 times.
386 * This is definitely not a streamer.
387 */
388 b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST);
389 //fputc('!', stderr);
390 }
391 }
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200392 /* unfortunately, on level-triggered events, POLL_HUP
393 * is generally delivered AFTER the system buffer is
394 * empty, so this one might never match.
395 */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100396 if (fdtab[fd].ev & FD_POLL_HUP)
397 goto out_shutdown_r;
Willy Tarreau2bea3a12008-08-28 09:47:43 +0200398
399 /* if a streamer has read few data, it may be because we
400 * have exhausted system buffers. It's not worth trying
401 * again.
402 */
403 if (b->flags & BF_STREAMER)
404 break;
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200405
Willy Tarreau6f4a82c2009-03-21 20:43:57 +0100406 /* generally if we read something smaller than 1 or 2 MSS,
407 * it means that either we have exhausted the system's
408 * buffers (streamer or question-response protocol) or
409 * that the connection will be closed. Streamers are
410 * easily detected so we return early. For other cases,
411 * it's still better to perform a last read to be sure,
412 * because it may save one complete poll/read/wakeup cycle
413 * in case of shutdown.
414 */
415 if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER)
416 break;
417
418 /* if we read a large block smaller than what we requested,
419 * it's almost certain we'll never get anything more.
420 */
421 if (ret >= global.tune.recv_enough)
422 break;
423 }
Willy Tarreau83749182007-04-15 20:56:27 +0200424
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100425 if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200426 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200427 }
428 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200429 /* connection closed */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100430 goto out_shutdown_r;
Willy Tarreau83749182007-04-15 20:56:27 +0200431 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200432 else if (errno == EAGAIN) {
433 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100434 * nothing to read left if we did not read much, ie
435 * less than what we were still expecting to read.
436 * But we may have done some work justifying to notify
437 * the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200438 */
Willy Tarreauaf78d0f2009-01-08 10:09:08 +0100439 if (cur_read < MIN_RET_FOR_READ_LOOP)
440 retval = 0;
Willy Tarreau83749182007-04-15 20:56:27 +0200441 break;
442 }
443 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200444 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200445 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200446 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200447
Willy Tarreau6996e152007-04-30 14:37:43 +0200448 out_wakeup:
Willy Tarreau22be90b2011-05-11 20:32:36 +0200449 /* We might have some data the consumer is waiting for.
450 * We can do fast-forwarding, but we avoid doing this for partial
451 * buffers, because it is very likely that it will be done again
452 * immediately afterwards once the following data is parsed (eg:
453 * HTTP chunking).
454 */
Willy Tarreaueb9fd512011-12-11 22:11:47 +0100455 if (b->pipe || /* always try to send spliced data */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100456 (b->i == 0 && (b->cons->flags & SI_FL_WAIT_DATA))) {
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100457 int last_len = b->pipe ? b->pipe->data : 0;
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100458
Willy Tarreau060781f2012-05-07 16:50:03 +0200459 b->cons->sock.chk_snd(b->cons);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100460
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100461 /* check if the consumer has freed some space */
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100462 if (!(b->flags & BF_FULL) &&
463 (!last_len || !b->pipe || b->pipe->data < last_len))
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100464 si->flags &= ~SI_FL_WAIT_ROOM;
465 }
466
467 if (si->flags & SI_FL_WAIT_ROOM) {
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100468 EV_FD_CLR(fd, DIR_RD);
469 b->rex = TICK_ETERNITY;
470 }
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200471 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 +0100472 b->rex = tick_add_ifset(now_ms, b->rto);
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100473
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100474 /* we have to wake up if there is a special event or if we don't have
475 * any more data to forward.
476 */
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200477 if ((b->flags & (BF_READ_NULL|BF_READ_ERROR)) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +0100478 si->state != SI_ST_EST ||
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200479 (si->flags & SI_FL_ERR) ||
480 ((b->flags & BF_READ_PARTIAL) && (!b->to_forward || b->cons->state != SI_ST_EST)))
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100481 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreau5af1fa12010-07-19 18:16:03 +0200482
483 if (b->flags & BF_READ_ACTIVITY)
484 b->flags &= ~BF_READ_DONTWAIT;
485
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100486 fdtab[fd].ev &= ~FD_POLL_IN;
Willy Tarreau83749182007-04-15 20:56:27 +0200487 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200488
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100489 out_shutdown_r:
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200490 /* we received a shutdown */
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100491 fdtab[fd].ev &= ~FD_POLL_HUP;
492 b->flags |= BF_READ_NULL;
Willy Tarreau520d95e2009-09-19 21:04:57 +0200493 if (b->flags & BF_AUTO_CLOSE)
Willy Tarreau418fd472009-09-06 21:37:23 +0200494 buffer_shutw_now(b);
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200495 sock_raw_shutr(si);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200496 goto out_wakeup;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100497
Willy Tarreau6996e152007-04-30 14:37:43 +0200498 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100499 /* Read error on the file descriptor. We mark the FD as STERROR so
500 * that we don't use it anymore. The error is reported to the stream
501 * interface which will take proper action. We must not perturbate the
502 * buffer because the stream interface wants to ensure transparent
503 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200504 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100505
Willy Tarreau6996e152007-04-30 14:37:43 +0200506 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100507 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100508 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100509 si->flags |= SI_FL_ERR;
Willy Tarreau9c0fe592009-01-18 16:25:31 +0100510 retval = 1;
511 goto out_wakeup;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200512}
513
514
515/*
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100516 * This function is called to send buffer data to a stream socket.
517 * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100518 * before calling it again, otherwise 1. If a pipe was associated with the
519 * buffer and it empties it, it releases it as well.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200520 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200521static int sock_raw_write_loop(struct stream_interface *si, struct buffer *b)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100522{
Willy Tarreau83749182007-04-15 20:56:27 +0200523 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100524 int retval = 1;
525 int ret, max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200526
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100527 if (unlikely(si->send_proxy_ofs)) {
528 /* The target server expects a PROXY line to be sent first.
529 * If the send_proxy_ofs is negative, it corresponds to the
530 * offset to start sending from then end of the proxy string
531 * (which is recomputed every time since it's constant). If
532 * it is positive, it means we have to send from the start.
533 */
David du Colombier7af46052012-05-16 14:16:48 +0200534 ret = make_proxy_line(trash, trashlen,
Willy Tarreau6471afb2011-09-23 10:54:59 +0200535 &b->prod->addr.from, &b->prod->addr.to);
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100536 if (!ret)
537 return -1;
538
539 if (si->send_proxy_ofs > 0)
540 si->send_proxy_ofs = -ret; /* first call */
541
542 /* we have to send trash from (ret+sp for -sp bytes) */
543 ret = send(si->fd, trash + ret + si->send_proxy_ofs, -si->send_proxy_ofs,
544 (b->flags & BF_OUT_EMPTY) ? 0 : MSG_MORE);
545 if (ret > 0) {
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200546 if (fdtab[si->fd].state == FD_STCONN) {
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100547 fdtab[si->fd].state = FD_STREADY;
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200548 si->exp = TICK_ETERNITY;
549 }
Willy Tarreaub22e55b2011-03-20 10:16:46 +0100550
551 si->send_proxy_ofs += ret; /* becomes zero once complete */
552 b->flags |= BF_WRITE_NULL; /* connect() succeeded */
553 }
554 else if (ret == 0 || errno == EAGAIN) {
555 /* nothing written, we need to poll for write first */
556 return 0;
557 }
558 else {
559 /* bad, we got an error */
560 return -1;
561 }
562 }
563
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100564#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100565 while (b->pipe) {
566 ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100567 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
568 if (ret <= 0) {
569 if (ret == 0 || errno == EAGAIN) {
570 retval = 0;
571 return retval;
572 }
573 /* here we have another error */
574 retval = -1;
575 return retval;
576 }
577
578 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100579 b->pipe->data -= ret;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100580
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100581 if (!b->pipe->data) {
582 put_pipe(b->pipe);
583 b->pipe = NULL;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100584 break;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100585 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100586
587 if (--write_poll <= 0)
588 return retval;
Willy Tarreaueb9fd512011-12-11 22:11:47 +0100589
590 /* The only reason we did not empty the pipe is that the output
591 * buffer is full.
592 */
593 return 0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100594 }
595
596 /* At this point, the pipe is empty, but we may still have data pending
597 * in the normal buffer.
598 */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100599#endif
Willy Tarreau2e046c62012-03-01 16:08:30 +0100600 if (!b->o) {
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200601 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100602 return retval;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200603 }
Willy Tarreau83749182007-04-15 20:56:27 +0200604
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100605 /* when we're in this loop, we already know that there is no spliced
606 * data left, and that there are sendable buffered data.
607 */
Willy Tarreau6996e152007-04-30 14:37:43 +0200608 while (1) {
Willy Tarreau89fa7062012-03-02 16:13:16 +0100609 max = b->o;
Willy Tarreau83749182007-04-15 20:56:27 +0200610
Willy Tarreau89fa7062012-03-02 16:13:16 +0100611 /* outgoing data may wrap at the end */
612 if (b->data + max > b->p)
613 max = b->data + max - b->p;
Willy Tarreauf890dc92008-12-13 21:12:26 +0100614
Willy Tarreau6db06d32009-08-19 11:14:11 +0200615 /* check if we want to inform the kernel that we're interested in
616 * sending more data after this call. We want this if :
617 * - we're about to close after this last send and want to merge
618 * the ongoing FIN with the last segment.
619 * - we know we can't send everything at once and must get back
620 * here because of unaligned data
Willy Tarreaud38b53b2010-01-03 11:18:34 +0100621 * - there is still a finite amount of data to forward
Willy Tarreau6db06d32009-08-19 11:14:11 +0200622 * The test is arranged so that the most common case does only 2
623 * tests.
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200624 */
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200625
Willy Tarreauface8392010-01-03 11:37:54 +0100626 if (MSG_NOSIGNAL && MSG_MORE) {
Willy Tarreau6db06d32009-08-19 11:14:11 +0200627 unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
628
Willy Tarreau96e31212011-05-30 18:10:30 +0200629 if ((!(b->flags & BF_NEVER_WAIT) &&
630 ((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
631 (b->flags & BF_EXPECT_MORE))) ||
Willy Tarreau2e046c62012-03-01 16:08:30 +0100632 ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->o)) ||
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100633 (max != b->o)) {
Willy Tarreauface8392010-01-03 11:37:54 +0100634 send_flag |= MSG_MORE;
635 }
Willy Tarreau6db06d32009-08-19 11:14:11 +0200636
Willy Tarreau2be39392010-01-03 17:24:51 +0100637 /* this flag has precedence over the rest */
638 if (b->flags & BF_SEND_DONTWAIT)
639 send_flag &= ~MSG_MORE;
640
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200641 ret = send(si->fd, bo_ptr(b), max, send_flag);
Willy Tarreaud6d06902009-08-19 11:22:33 +0200642 } else {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200643 int skerr;
644 socklen_t lskerr = sizeof(skerr);
645
Willy Tarreau87bed622009-03-08 22:25:28 +0100646 ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
Willy Tarreauc6423482006-10-15 14:59:03 +0200647 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200648 ret = -1;
649 else
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200650 ret = send(si->fd, bo_ptr(b), max, MSG_DONTWAIT);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200651 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200652
653 if (ret > 0) {
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200654 if (fdtab[si->fd].state == FD_STCONN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100655 fdtab[si->fd].state = FD_STREADY;
Willy Tarreau8ae52cb2012-05-20 10:38:46 +0200656 si->exp = TICK_ETERNITY;
657 }
Willy Tarreaub38903c2008-11-23 21:33:29 +0100658
Willy Tarreau3da77c52008-08-29 09:58:42 +0200659 b->flags |= BF_WRITE_PARTIAL;
Willy Tarreaue393fe22008-08-16 22:18:07 +0200660
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100661 b->o -= ret;
662 if (likely(!buffer_len(b)))
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100663 /* optimize data alignment in the buffer */
Willy Tarreaua458b672012-03-05 11:17:50 +0100664 b->p = b->data;
Willy Tarreau83749182007-04-15 20:56:27 +0200665
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200666 if (likely(!bi_full(b)))
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100667 b->flags &= ~BF_FULL;
668
Willy Tarreau2e046c62012-03-01 16:08:30 +0100669 if (!b->o) {
Willy Tarreauf17810e2012-03-09 18:10:44 +0100670 /* Always clear both flags once everything has been sent, they're one-shot */
671 b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT);
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200672 if (likely(!b->pipe))
673 b->flags |= BF_OUT_EMPTY;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100674 break;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200675 }
Willy Tarreau83749182007-04-15 20:56:27 +0200676
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200677 /* if the system buffer is full, don't insist */
678 if (ret < max)
679 break;
680
Willy Tarreau6996e152007-04-30 14:37:43 +0200681 if (--write_poll <= 0)
682 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200683 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200684 else if (ret == 0 || errno == EAGAIN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100685 /* nothing written, we need to poll for write first */
Willy Tarreau83749182007-04-15 20:56:27 +0200686 retval = 0;
687 break;
688 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200689 else {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100690 /* bad, we got an error */
691 retval = -1;
692 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200693 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200694 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200695
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100696 return retval;
697}
Willy Tarreau6996e152007-04-30 14:37:43 +0200698
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100699
700/*
701 * This function is called on a write event from a stream socket.
702 * It returns 0 if the caller needs to poll before calling it again, otherwise
703 * non-zero.
704 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200705static int sock_raw_write(int fd)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100706{
707 struct stream_interface *si = fdtab[fd].owner;
708 struct buffer *b = si->ob;
709 int retval = 1;
710
711#ifdef DEBUG_FULL
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200712 fprintf(stderr,"sock_raw_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100713#endif
714
715 retval = 1;
Willy Tarreau71543652009-07-14 19:55:05 +0200716 if (fdtab[fd].state == FD_STERROR)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100717 goto out_error;
718
Willy Tarreaud06e7112009-03-29 10:18:41 +0200719 /* we might have been called just after an asynchronous shutw */
720 if (b->flags & BF_SHUTW)
721 goto out_wakeup;
722
Willy Tarreaueeda90e2012-05-11 19:53:32 +0200723 retval = sock_raw_write_loop(si, b);
724 if (retval < 0)
725 goto out_error;
726 else if (retval == 0 && si->send_proxy_ofs)
727 goto out_may_wakeup; /* we failed to send the PROXY string */
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100728
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200729 if (b->flags & BF_OUT_EMPTY) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100730 /* the connection is established but we can't write. Either the
731 * buffer is empty, or we just refrain from sending because the
Willy Tarreau2e046c62012-03-01 16:08:30 +0100732 * ->o limit was reached. Maybe we just wrote the last
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100733 * chunk and need to close.
734 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200735 if (((b->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100736 (si->state == SI_ST_EST)) {
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200737 sock_raw_shutw(si);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100738 goto out_wakeup;
739 }
740
Willy Tarreau59454bf2009-09-20 11:13:40 +0200741 if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreauac128fe2009-01-09 13:05:19 +0100742 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100743
Willy Tarreauac128fe2009-01-09 13:05:19 +0100744 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100745 b->wex = TICK_ETERNITY;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100746 }
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100747
748 out_may_wakeup:
749 if (b->flags & BF_WRITE_ACTIVITY) {
750 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200751 if ((b->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100752 b->wex = tick_add_ifset(now_ms, b->wto);
753
754 out_wakeup:
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200755 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100756 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200757 * during writes, we refresh it. We only do this if the
758 * interface is not configured for "independant streams",
759 * because for some applications it's better not to do this,
760 * for instance when continuously exchanging small amounts
761 * of data which can full the socket buffers long before a
762 * write timeout is detected.
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100763 */
764 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
765 }
766
767 /* the producer might be waiting for more room to store data */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200768 if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL|BF_DONT_READ)) == BF_WRITE_PARTIAL &&
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100769 (b->prod->flags & SI_FL_WAIT_ROOM)))
Willy Tarreau060781f2012-05-07 16:50:03 +0200770 b->prod->sock.chk_rcv(b->prod);
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100771
772 /* we have to wake up if there is a special event or if we don't have
773 * any more data to forward and it's not planned to send any more.
774 */
775 if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200776 ((b->flags & BF_OUT_EMPTY) && !b->to_forward) ||
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100777 si->state != SI_ST_EST ||
778 b->prod->state != SI_ST_EST))
779 task_wakeup(si->owner, TASK_WOKEN_IO);
780 }
781
782 fdtab[fd].ev &= ~FD_POLL_OUT;
783 return retval;
Willy Tarreauac128fe2009-01-09 13:05:19 +0100784
Willy Tarreau6996e152007-04-30 14:37:43 +0200785 out_error:
Willy Tarreaucff64112008-11-03 06:26:53 +0100786 /* Write error on the file descriptor. We mark the FD as STERROR so
787 * that we don't use it anymore. The error is reported to the stream
788 * interface which will take proper action. We must not perturbate the
789 * buffer because the stream interface wants to ensure transparent
790 * connection retries.
Willy Tarreau6996e152007-04-30 14:37:43 +0200791 */
Willy Tarreaucff64112008-11-03 06:26:53 +0100792
Willy Tarreau6996e152007-04-30 14:37:43 +0200793 fdtab[fd].state = FD_STERROR;
Willy Tarreaud6f087e2008-01-18 17:20:13 +0100794 fdtab[fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +0100795 EV_FD_REM(fd);
Willy Tarreaucff64112008-11-03 06:26:53 +0100796 si->flags |= SI_FL_ERR;
Willy Tarreaue5ed4062008-08-30 03:17:31 +0200797 task_wakeup(si->owner, TASK_WOKEN_IO);
798 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200799}
800
Willy Tarreau48adac52008-08-30 04:58:38 +0200801/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200802 * This function performs a shutdown-write on a stream interface in a connected or
803 * init state (it does nothing for other states). It either shuts the write side
Willy Tarreau99126c32008-11-27 10:30:51 +0100804 * or closes the file descriptor and marks itself as closed. The buffer flags are
Willy Tarreau7340ca52010-01-16 10:03:45 +0100805 * updated to reflect the new state. It does also close everything is the SI was
806 * marked as being in error state.
Willy Tarreau48adac52008-08-30 04:58:38 +0200807 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200808static void sock_raw_shutw(struct stream_interface *si)
Willy Tarreau48adac52008-08-30 04:58:38 +0200809{
Willy Tarreau418fd472009-09-06 21:37:23 +0200810 si->ob->flags &= ~BF_SHUTW_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100811 if (si->ob->flags & BF_SHUTW)
812 return;
813 si->ob->flags |= BF_SHUTW;
814 si->ob->wex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100815 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau99126c32008-11-27 10:30:51 +0100816
Willy Tarreaub38903c2008-11-23 21:33:29 +0100817 switch (si->state) {
Willy Tarreaub38903c2008-11-23 21:33:29 +0100818 case SI_ST_EST:
Willy Tarreau720058c2009-07-14 19:21:50 +0200819 /* we have to shut before closing, otherwise some short messages
820 * may never leave the system, especially when there are remaining
821 * unread data in the socket input buffer, or when nolinger is set.
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100822 * However, if SI_FL_NOLINGER is explicitly set, we know there is
823 * no risk so we close both sides immediately.
Willy Tarreau720058c2009-07-14 19:21:50 +0200824 */
Willy Tarreau7340ca52010-01-16 10:03:45 +0100825 if (si->flags & SI_FL_ERR) {
826 /* quick close, the socket is already shut. Remove pending flags. */
827 si->flags &= ~SI_FL_NOLINGER;
Willy Tarreau7bb68ab2012-05-13 14:48:59 +0200828 }
829 else if (si->flags & SI_FL_NOLINGER) {
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100830 si->flags &= ~SI_FL_NOLINGER;
831 setsockopt(si->fd, SOL_SOCKET, SO_LINGER,
832 (struct linger *) &nolinger, sizeof(struct linger));
Willy Tarreau7bb68ab2012-05-13 14:48:59 +0200833 }
834 else if (!(si->flags & SI_FL_NOHALF)) {
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100835 EV_FD_CLR(si->fd, DIR_WR);
836 shutdown(si->fd, SHUT_WR);
Willy Tarreau720058c2009-07-14 19:21:50 +0200837
Willy Tarreau4c283dc2009-12-29 14:36:34 +0100838 if (!(si->ib->flags & (BF_SHUTR|BF_DONT_READ)))
839 return;
840 }
Willy Tarreau5d707e12009-06-28 11:09:07 +0200841
Willy Tarreaub38903c2008-11-23 21:33:29 +0100842 /* fall through */
843 case SI_ST_CON:
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100844 /* we may have to close a pending connection, and mark the
845 * response buffer as shutr
846 */
Willy Tarreau48adac52008-08-30 04:58:38 +0200847 fd_delete(si->fd);
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100848 /* fall through */
849 case SI_ST_CER:
Willy Tarreau32d3ee92010-12-29 14:03:02 +0100850 case SI_ST_QUE:
851 case SI_ST_TAR:
Willy Tarreau7f006512008-12-07 14:04:04 +0100852 si->state = SI_ST_DIS;
Willy Tarreauad4cd582012-03-10 13:42:32 +0100853
854 if (si->release)
855 si->release(si);
Willy Tarreau7f006512008-12-07 14:04:04 +0100856 default:
Willy Tarreaud06e7112009-03-29 10:18:41 +0200857 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100858 si->ib->flags |= BF_SHUTR;
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100859 si->ib->rex = TICK_ETERNITY;
Willy Tarreau127334e2009-03-28 10:47:26 +0100860 si->exp = TICK_ETERNITY;
Willy Tarreau48adac52008-08-30 04:58:38 +0200861 }
Willy Tarreau48adac52008-08-30 04:58:38 +0200862}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200863
Willy Tarreau2d212792008-08-27 21:41:35 +0200864/*
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200865 * This function performs a shutdown-read on a stream interface in a connected or
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100866 * init state (it does nothing for other states). It either shuts the read side
Willy Tarreau99126c32008-11-27 10:30:51 +0100867 * or closes the file descriptor and marks itself as closed. The buffer flags are
Willy Tarreau7bb68ab2012-05-13 14:48:59 +0200868 * updated to reflect the new state. If the stream interface has SI_FL_NOHALF,
869 * we also forward the close to the write side.
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200870 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200871static void sock_raw_shutr(struct stream_interface *si)
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200872{
Willy Tarreau418fd472009-09-06 21:37:23 +0200873 si->ib->flags &= ~BF_SHUTR_NOW;
Willy Tarreau99126c32008-11-27 10:30:51 +0100874 if (si->ib->flags & BF_SHUTR)
875 return;
876 si->ib->flags |= BF_SHUTR;
877 si->ib->rex = TICK_ETERNITY;
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100878 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau99126c32008-11-27 10:30:51 +0100879
Willy Tarreau8bfa4262008-11-27 09:25:45 +0100880 if (si->state != SI_ST_EST && si->state != SI_ST_CON)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100881 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200882
Willy Tarreaucff64112008-11-03 06:26:53 +0100883 if (si->ob->flags & BF_SHUTW) {
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200884 fd_delete(si->fd);
Willy Tarreau74ab2ac2008-11-23 17:23:07 +0100885 si->state = SI_ST_DIS;
Willy Tarreau127334e2009-03-28 10:47:26 +0100886 si->exp = TICK_ETERNITY;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200887
888 if (si->release)
889 si->release(si);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100890 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200891 }
Willy Tarreau7bb68ab2012-05-13 14:48:59 +0200892 else if (si->flags & SI_FL_NOHALF) {
893 /* we want to immediately forward this close to the write side */
894 return sock_raw_shutw(si);
895 }
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200896 EV_FD_CLR(si->fd, DIR_RD);
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100897 return;
Willy Tarreau3c6ab2e2008-09-04 11:19:41 +0200898}
899
900/*
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200901 * Updates a connected sock_raw file descriptor status and timeouts
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200902 * according to the buffers' flags. It should only be called once after the
903 * buffer flags have settled down, and before they are cleared. It doesn't
904 * harm to call it as often as desired (it just slightly hurts performance).
905 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200906static void sock_raw_data_finish(struct stream_interface *si)
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200907{
Willy Tarreaub0253252008-11-30 21:37:12 +0100908 struct buffer *ib = si->ib;
909 struct buffer *ob = si->ob;
910 int fd = si->fd;
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200911
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100912 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 +0200913 now_ms, __FUNCTION__,
914 fd, fdtab[fd].owner,
915 ib, ob,
916 ib->rex, ob->wex,
917 ib->flags, ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100918 ib->i, ib->o, ob->i, ob->o, si->state);
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200919
920 /* Check if we need to close the read side */
921 if (!(ib->flags & BF_SHUTR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200922 /* Read not closed, update FD status and timeout for reads */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200923 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200924 /* stop reading */
Willy Tarreau11f49402010-11-11 23:08:17 +0100925 if (!(si->flags & SI_FL_WAIT_ROOM)) {
926 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
927 si->flags |= SI_FL_WAIT_ROOM;
928 EV_FD_COND_C(fd, DIR_RD);
929 ib->rex = TICK_ETERNITY;
930 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200931 }
932 else {
933 /* (re)start reading and update timeout. Note: we don't recompute the timeout
934 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200935 * update it if is was not yet set. The stream socket handler will already
936 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200937 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100938 si->flags &= ~SI_FL_WAIT_ROOM;
Willy Tarreau2d212792008-08-27 21:41:35 +0200939 EV_FD_COND_S(fd, DIR_RD);
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200940 if (!(ib->flags & (BF_READ_NOEXP|BF_DONT_READ)) && !tick_isset(ib->rex))
Willy Tarreau2d212792008-08-27 21:41:35 +0200941 ib->rex = tick_add_ifset(now_ms, ib->rto);
942 }
943 }
944
945 /* Check if we need to close the write side */
946 if (!(ob->flags & BF_SHUTW)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200947 /* Write not closed, update FD status and timeout for writes */
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200948 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200949 /* stop writing */
Willy Tarreau11f49402010-11-11 23:08:17 +0100950 if (!(si->flags & SI_FL_WAIT_DATA)) {
951 if ((ob->flags & (BF_FULL|BF_HIJACK|BF_SHUTW_NOW)) == 0)
952 si->flags |= SI_FL_WAIT_DATA;
953 EV_FD_COND_C(fd, DIR_WR);
954 ob->wex = TICK_ETERNITY;
955 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200956 }
957 else {
958 /* (re)start writing and update timeout. Note: we don't recompute the timeout
959 * everytime we get here, otherwise it would risk never to expire. We only
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200960 * update it if is was not yet set. The stream socket handler will already
961 * have updated it if there has been a completed I/O.
Willy Tarreau2d212792008-08-27 21:41:35 +0200962 */
Willy Tarreaub0ef7352008-12-14 13:26:20 +0100963 si->flags &= ~SI_FL_WAIT_DATA;
Willy Tarreau2d212792008-08-27 21:41:35 +0200964 EV_FD_COND_S(fd, DIR_WR);
Willy Tarreaufe8903c2009-10-04 10:56:08 +0200965 if (!tick_isset(ob->wex)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200966 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200967 if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreau2d212792008-08-27 21:41:35 +0200968 /* Note: depending on the protocol, we don't know if we're waiting
969 * for incoming data or not. So in order to prevent the socket from
970 * expiring read timeouts during writes, we refresh the read timeout,
Willy Tarreauf27b5ea2009-10-03 22:01:18 +0200971 * except if it was already infinite or if we have explicitly setup
972 * independant streams.
Willy Tarreau2d212792008-08-27 21:41:35 +0200973 */
Willy Tarreaud06e7112009-03-29 10:18:41 +0200974 ib->rex = tick_add_ifset(now_ms, ib->rto);
Willy Tarreau2d212792008-08-27 21:41:35 +0200975 }
976 }
977 }
978 }
Willy Tarreau2d212792008-08-27 21:41:35 +0200979}
980
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100981/* This function is used for inter-stream-interface calls. It is called by the
982 * consumer to inform the producer side that it may be interested in checking
983 * for free space in the buffer. Note that it intentionally does not update
984 * timeouts, so that we can still check them later at wake-up.
985 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +0200986static void sock_raw_chk_rcv(struct stream_interface *si)
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100987{
988 struct buffer *ib = si->ib;
989
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100990 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 +0100991 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +0000992 si->fd, fdtab[si->fd].owner,
993 ib, si->ob,
994 ib->rex, si->ob->wex,
995 ib->flags, si->ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100996 ib->i, ib->o, si->ob->i, si->ob->o, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +0100997
998 if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
999 return;
1000
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001001 if (ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) {
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001002 /* stop reading */
Willy Tarreauf1ba4b32009-10-17 14:37:52 +02001003 if ((ib->flags & (BF_FULL|BF_HIJACK|BF_DONT_READ)) == BF_FULL)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001004 si->flags |= SI_FL_WAIT_ROOM;
1005 EV_FD_COND_C(si->fd, DIR_RD);
1006 }
1007 else {
1008 /* (re)start reading */
1009 si->flags &= ~SI_FL_WAIT_ROOM;
1010 EV_FD_COND_S(si->fd, DIR_RD);
1011 }
1012}
1013
1014
1015/* This function is used for inter-stream-interface calls. It is called by the
1016 * producer to inform the consumer side that it may be interested in checking
1017 * for data in the buffer. Note that it intentionally does not update timeouts,
1018 * so that we can still check them later at wake-up.
1019 */
Willy Tarreaub277d6e2012-05-11 16:59:14 +02001020static void sock_raw_chk_snd(struct stream_interface *si)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001021{
1022 struct buffer *ob = si->ob;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001023 int retval;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001024
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001025 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 +01001026 now_ms, __FUNCTION__,
Vincenzo Farruggia9b97cff2009-01-30 16:49:10 +00001027 si->fd, fdtab[si->fd].owner,
1028 si->ib, ob,
1029 si->ib->rex, ob->wex,
1030 si->ib->flags, ob->flags,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001031 si->ib->i, si->ib->o, ob->i, ob->o, si->state);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001032
1033 if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
1034 return;
1035
Willy Tarreaueb9fd512011-12-11 22:11:47 +01001036 if (unlikely((ob->flags & BF_OUT_EMPTY) && !(si->send_proxy_ofs))) /* called with nothing to send ! */
1037 return;
1038
1039 if (!ob->pipe && /* spliced data wants to be forwarded ASAP */
1040 (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
1041 (fdtab[si->fd].ev & FD_POLL_OUT))) /* we'll be called anyway */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001042 return;
1043
Willy Tarreaub277d6e2012-05-11 16:59:14 +02001044 retval = sock_raw_write_loop(si, ob);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001045 /* here, we have :
1046 * retval < 0 if an error was encountered during write.
1047 * retval = 0 if we can't write anymore without polling
1048 * retval = 1 if we're invited to come back when desired
1049 */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001050 if (retval < 0) {
1051 /* Write error on the file descriptor. We mark the FD as STERROR so
1052 * that we don't use it anymore and we notify the task.
1053 */
1054 fdtab[si->fd].state = FD_STERROR;
1055 fdtab[si->fd].ev &= ~FD_POLL_STICKY;
Willy Tarreau1714e0f2009-03-28 20:54:53 +01001056 EV_FD_REM(si->fd);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001057 si->flags |= SI_FL_ERR;
1058 goto out_wakeup;
1059 }
Willy Tarreau68f49da2011-03-28 23:17:54 +02001060 else if (retval == 0 && si->send_proxy_ofs)
1061 goto out_may_wakeup; /* we failed to send the PROXY string */
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001062
Willy Tarreauc54aef32009-07-27 20:08:06 +02001063 /* OK, so now we know that retval >= 0 means that some data might have
1064 * been sent, and that we may have to poll first. We have to do that
1065 * too if the buffer is not empty.
1066 */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001067 if (ob->flags & BF_OUT_EMPTY) {
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001068 /* the connection is established but we can't write. Either the
1069 * buffer is empty, or we just refrain from sending because the
Willy Tarreau2e046c62012-03-01 16:08:30 +01001070 * ->o limit was reached. Maybe we just wrote the last
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001071 * chunk and need to close.
1072 */
Willy Tarreau520d95e2009-09-19 21:04:57 +02001073 if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==
1074 (BF_AUTO_CLOSE|BF_SHUTW_NOW)) &&
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001075 (si->state == SI_ST_EST)) {
Willy Tarreaub277d6e2012-05-11 16:59:14 +02001076 sock_raw_shutw(si);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001077 goto out_wakeup;
1078 }
Willy Tarreaud06e7112009-03-29 10:18:41 +02001079
Willy Tarreau59454bf2009-09-20 11:13:40 +02001080 if ((ob->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_FULL|BF_HIJACK)) == 0)
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001081 si->flags |= SI_FL_WAIT_DATA;
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001082 ob->wex = TICK_ETERNITY;
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001083 }
1084 else {
Willy Tarreauc54aef32009-07-27 20:08:06 +02001085 /* Otherwise there are remaining data to be sent in the buffer,
1086 * which means we have to poll before doing so.
1087 */
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001088 EV_FD_COND_S(si->fd, DIR_WR);
Willy Tarreauc54aef32009-07-27 20:08:06 +02001089 si->flags &= ~SI_FL_WAIT_DATA;
1090 if (!tick_isset(ob->wex))
1091 ob->wex = tick_add_ifset(now_ms, ob->wto);
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001092 }
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001093
Willy Tarreau68f49da2011-03-28 23:17:54 +02001094 out_may_wakeup:
Willy Tarreauc9619462009-03-09 22:40:57 +01001095 if (likely(ob->flags & BF_WRITE_ACTIVITY)) {
1096 /* update timeout if we have written something */
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001097 if ((ob->flags & (BF_OUT_EMPTY|BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL)
Willy Tarreauc9619462009-03-09 22:40:57 +01001098 ob->wex = tick_add_ifset(now_ms, ob->wto);
1099
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001100 if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
Willy Tarreauc9619462009-03-09 22:40:57 +01001101 /* Note: to prevent the client from expiring read timeouts
Willy Tarreauf27b5ea2009-10-03 22:01:18 +02001102 * during writes, we refresh it. We only do this if the
1103 * interface is not configured for "independant streams",
1104 * because for some applications it's better not to do this,
1105 * for instance when continuously exchanging small amounts
1106 * of data which can full the socket buffers long before a
1107 * write timeout is detected.
Willy Tarreauc9619462009-03-09 22:40:57 +01001108 */
1109 si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
1110 }
1111 }
1112
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001113 /* in case of special condition (error, shutdown, end of write...), we
1114 * have to notify the task.
1115 */
1116 if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) ||
Willy Tarreauba0b63d2009-09-20 08:09:44 +02001117 ((ob->flags & BF_OUT_EMPTY) && !ob->to_forward) ||
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001118 si->state != SI_ST_EST)) {
1119 out_wakeup:
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001120 if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
1121 task_wakeup(si->owner, TASK_WOKEN_IO);
Willy Tarreaua456f2a2009-01-18 17:38:44 +01001122 }
Willy Tarreau3ffeba12008-12-14 14:42:35 +01001123}
1124
Willy Tarreau5c979a92012-05-07 17:15:39 +02001125/* stream sock operations */
Willy Tarreaub277d6e2012-05-11 16:59:14 +02001126struct sock_ops sock_raw = {
1127 .update = sock_raw_data_finish,
1128 .shutr = sock_raw_shutr,
1129 .shutw = sock_raw_shutw,
1130 .chk_rcv = sock_raw_chk_rcv,
1131 .chk_snd = sock_raw_chk_snd,
1132 .read = sock_raw_read,
1133 .write = sock_raw_write,
Willy Tarreau5c979a92012-05-07 17:15:39 +02001134};
Willy Tarreaubaaee002006-06-26 02:48:02 +02001135
1136/*
1137 * Local variables:
1138 * c-indent-level: 8
1139 * c-basic-offset: 8
1140 * End:
1141 */