blob: e420ace348e2b15753ac409b05fb11e8bcfcd480 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Functions operating on SOCK_STREAM and buffers.
3 *
Willy Tarreaue09e0ce2007-03-18 16:31:29 +01004 * Copyright 2000-2007 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
13#include <errno.h>
14#include <fcntl.h>
15#include <stdio.h>
16#include <stdlib.h>
17
18#include <sys/socket.h>
19#include <sys/stat.h>
20#include <sys/types.h>
21
Willy Tarreau2dd0d472006-06-29 17:53:05 +020022#include <common/compat.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020023#include <common/config.h>
Willy Tarreau83749182007-04-15 20:56:27 +020024#include <common/standard.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020025#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020026
Willy Tarreaubaaee002006-06-26 02:48:02 +020027#include <types/buffers.h>
28#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020029#include <types/polling.h>
Willy Tarreau6996e152007-04-30 14:37:43 +020030#include <types/session.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020031
32#include <proto/client.h>
33#include <proto/fd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <proto/stream_sock.h>
35#include <proto/task.h>
36
37
38/*
Willy Tarreaud7971282006-07-29 18:36:34 +020039 * this function is called on a read event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +020040 * It returns 0 if we have a high confidence that we will not be
41 * able to read more data without polling first. Returns non-zero
42 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +020043 */
Willy Tarreaud7971282006-07-29 18:36:34 +020044int stream_sock_read(int fd) {
Willy Tarreau6996e152007-04-30 14:37:43 +020045 __label__ out_eternity, out_wakeup, out_error;
Willy Tarreau54469402006-07-29 16:59:06 +020046 struct buffer *b = fdtab[fd].cb[DIR_RD].b;
Willy Tarreau83749182007-04-15 20:56:27 +020047 int ret, max, retval;
Willy Tarreaub8949f12007-03-23 22:39:59 +010048 int read_poll = MAX_READ_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +020049
50#ifdef DEBUG_FULL
Willy Tarreaud7971282006-07-29 18:36:34 +020051 fprintf(stderr,"stream_sock_read : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
Willy Tarreaubaaee002006-06-26 02:48:02 +020052#endif
53
Willy Tarreau83749182007-04-15 20:56:27 +020054 retval = 1;
55
Willy Tarreau83749182007-04-15 20:56:27 +020056 if (unlikely(fdtab[fd].ev & FD_POLL_HUP)) {
57 /* connection closed */
58 b->flags |= BF_READ_NULL;
Willy Tarreau6996e152007-04-30 14:37:43 +020059 goto out_eternity;
60 }
61 else if (unlikely(fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR))) {
62 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +020063 }
64
Willy Tarreau6996e152007-04-30 14:37:43 +020065 while (1) {
66 /*
67 * 1. compute the maximum block size we can read at once.
68 */
Willy Tarreau83749182007-04-15 20:56:27 +020069 if (b->l == 0) { /* let's realign the buffer to optimize I/O */
70 b->r = b->w = b->lr = b->data;
71 max = b->rlim - b->data;
72 }
73 else if (b->r > b->w) {
74 max = b->rlim - b->r;
75 }
76 else {
77 max = b->w - b->r;
78 /* FIXME: theorically, if w>0, we shouldn't have rlim < data+size anymore
79 * since it means that the rewrite protection has been removed. This
80 * implies that the if statement can be removed.
81 */
82 if (max > b->rlim - b->data)
Willy Tarreaubaaee002006-06-26 02:48:02 +020083 max = b->rlim - b->data;
Willy Tarreau83749182007-04-15 20:56:27 +020084 }
Willy Tarreaubaaee002006-06-26 02:48:02 +020085
Willy Tarreau6996e152007-04-30 14:37:43 +020086 if (unlikely(max == 0)) {
87 /* Not anymore room to store data. This should theorically
88 * never happen, but better safe than sorry !
89 */
Willy Tarreau83749182007-04-15 20:56:27 +020090 EV_FD_CLR(fd, DIR_RD);
Willy Tarreau6996e152007-04-30 14:37:43 +020091 goto out_eternity;
Willy Tarreau83749182007-04-15 20:56:27 +020092 }
Willy Tarreaubaaee002006-06-26 02:48:02 +020093
Willy Tarreau6996e152007-04-30 14:37:43 +020094 /*
95 * 2. read the largest possible block
96 */
Willy Tarreaubaaee002006-06-26 02:48:02 +020097#ifndef MSG_NOSIGNAL
Willy Tarreau83749182007-04-15 20:56:27 +020098 {
99 int skerr;
100 socklen_t lskerr = sizeof(skerr);
101
102 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
103 if (ret == -1 || skerr)
104 ret = -1;
105 else
106 ret = recv(fd, b->r, max, 0);
107 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200108#else
Willy Tarreau83749182007-04-15 20:56:27 +0200109 ret = recv(fd, b->r, max, MSG_NOSIGNAL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200110#endif
Willy Tarreau83749182007-04-15 20:56:27 +0200111 if (ret > 0) {
112 b->r += ret;
113 b->l += ret;
114 b->flags |= BF_PARTIAL_READ;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200115
Willy Tarreau83749182007-04-15 20:56:27 +0200116 if (b->r == b->data + BUFSIZE) {
117 b->r = b->data; /* wrap around the buffer */
118 }
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100119
Willy Tarreau83749182007-04-15 20:56:27 +0200120 b->total += ret;
Willy Tarreau9641e8f2007-03-23 23:02:09 +0100121
Willy Tarreau6996e152007-04-30 14:37:43 +0200122 if (b->l == b->rlim - b->data) {
123 /* The buffer is now full, there's no point in going through
124 * the loop again.
125 */
126 EV_FD_CLR(fd, DIR_RD);
127 goto out_eternity;
128 }
129
Willy Tarreau83749182007-04-15 20:56:27 +0200130 /* generally if we read something smaller than the 1 or 2 MSS,
131 * it means that it's not worth trying to read again. It may
132 * also happen on headers, but the application then can stop
133 * reading before we start polling.
134 */
135 if (ret < MIN_RET_FOR_READ_LOOP)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200136 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200137
Willy Tarreau6996e152007-04-30 14:37:43 +0200138 if (--read_poll <= 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200139 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200140
Willy Tarreau83749182007-04-15 20:56:27 +0200141 }
142 else if (ret == 0) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200143 /* connection closed */
Willy Tarreau83749182007-04-15 20:56:27 +0200144 b->flags |= BF_READ_NULL;
Willy Tarreau6996e152007-04-30 14:37:43 +0200145 goto out_eternity;
Willy Tarreau83749182007-04-15 20:56:27 +0200146 }
Willy Tarreau9f195292007-04-15 21:26:58 +0200147 else if (errno == EAGAIN) {
148 /* Ignore EAGAIN but inform the poller that there is
Willy Tarreau6996e152007-04-30 14:37:43 +0200149 * nothing to read left. But we may have done some work
150 * justifying to notify the task.
Willy Tarreau9f195292007-04-15 21:26:58 +0200151 */
Willy Tarreau83749182007-04-15 20:56:27 +0200152 retval = 0;
153 break;
154 }
155 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200156 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200157 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200158 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200159
Willy Tarreau6996e152007-04-30 14:37:43 +0200160 /*
161 * The only way to get out of this loop is to have stopped reading
162 * without any error nor close, either by limiting the number of
163 * loops, or because of an EAGAIN. We only rearm the timer if we
164 * have at least read something.
165 */
166
167 if (b->flags & BF_PARTIAL_READ) {
168 if (b->rto) {
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200169 tv_ms_add(&b->rex, &now, b->rto);
Willy Tarreau6996e152007-04-30 14:37:43 +0200170 goto out_wakeup;
171 }
172 out_eternity:
173 tv_eternity(&b->rex);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200174 }
175
Willy Tarreau6996e152007-04-30 14:37:43 +0200176 out_wakeup:
177 if (b->flags & BF_READ_STATUS)
178 task_wakeup(fdtab[fd].owner);
Willy Tarreau83749182007-04-15 20:56:27 +0200179 fdtab[fd].ev &= ~FD_POLL_RD;
180 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200181
182 out_error:
183 /* There was an error. we must wakeup the task. No need to clear
184 * the events, the task will do it.
185 */
186 fdtab[fd].state = FD_STERROR;
187 b->flags |= BF_READ_ERROR;
188 goto out_eternity;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200189}
190
191
192/*
Willy Tarreauf8306d52006-07-29 19:01:31 +0200193 * this function is called on a write event from a stream socket.
Willy Tarreau83749182007-04-15 20:56:27 +0200194 * It returns 0 if we have a high confidence that we will not be
195 * able to write more data without polling first. Returns non-zero
196 * otherwise.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200197 */
Willy Tarreauf8306d52006-07-29 19:01:31 +0200198int stream_sock_write(int fd) {
Willy Tarreau6996e152007-04-30 14:37:43 +0200199 __label__ out_eternity, out_wakeup, out_error;
Willy Tarreau54469402006-07-29 16:59:06 +0200200 struct buffer *b = fdtab[fd].cb[DIR_WR].b;
Willy Tarreau83749182007-04-15 20:56:27 +0200201 int ret, max, retval;
202 int write_poll = MAX_WRITE_POLL_LOOPS;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200203
204#ifdef DEBUG_FULL
Willy Tarreauf8306d52006-07-29 19:01:31 +0200205 fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200206#endif
207
Willy Tarreau83749182007-04-15 20:56:27 +0200208 retval = 1;
Willy Tarreau6996e152007-04-30 14:37:43 +0200209 if (unlikely(fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)))
210 goto out_error;
Willy Tarreau83749182007-04-15 20:56:27 +0200211
Willy Tarreau6996e152007-04-30 14:37:43 +0200212 while (1) {
Willy Tarreau83749182007-04-15 20:56:27 +0200213 if (b->l == 0) { /* let's realign the buffer to optimize I/O */
214 b->r = b->w = b->lr = b->data;
215 max = 0;
216 }
217 else if (b->r > b->w) {
218 max = b->r - b->w;
219 }
220 else {
221 max = b->data + BUFSIZE - b->w;
222 }
223
Willy Tarreaubaaee002006-06-26 02:48:02 +0200224 if (max == 0) {
Willy Tarreauf8306d52006-07-29 19:01:31 +0200225 /* may be we have received a connection acknowledgement in TCP mode without data */
Willy Tarreau6996e152007-04-30 14:37:43 +0200226 if (likely(fdtab[fd].state == FD_STCONN)) {
227 struct session *s = fdtab[fd].owner->context;
228
229 /* We have no data to send to check the connection, and
230 * getsockopt() will not inform us whether the connection
231 * is still pending. So we'll reuse connect() to check the
232 * state of the socket. This has the advantage of givig us
233 * the following info :
234 * - error
235 * - connecting (EALREADY, EINPROGRESS)
236 * - connected (EISCONN, 0)
237 */
238 if ((connect(fd, (struct sockaddr *)&s->srv_addr, sizeof(s->srv_addr)) == 0))
239 errno = 0;
240
241 if (errno == EALREADY || errno == EINPROGRESS) {
242 retval = 0;
243 goto out_wakeup;
Willy Tarreauf8306d52006-07-29 19:01:31 +0200244 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200245
246 if (errno && errno != EISCONN)
247 goto out_error;
248
249 /* OK we just need to indicate that we got a connection
250 * and that we wrote nothing.
251 */
252 b->flags |= BF_WRITE_NULL;
253 fdtab[fd].state = FD_STREADY;
Willy Tarreauf8306d52006-07-29 19:01:31 +0200254 }
255
Willy Tarreau6996e152007-04-30 14:37:43 +0200256 /* Funny, we were called to write something but there wasn't
257 * anything. Theorically we cannot get there, but just in case,
258 * let's disable the write event and pretend we never came there.
259 */
Willy Tarreauf161a342007-04-08 16:59:42 +0200260 EV_FD_CLR(fd, DIR_WR);
Willy Tarreau83749182007-04-15 20:56:27 +0200261 goto out_eternity;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200262 }
263
264#ifndef MSG_NOSIGNAL
265 {
266 int skerr;
267 socklen_t lskerr = sizeof(skerr);
268
Willy Tarreauc6423482006-10-15 14:59:03 +0200269 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
270 if (ret == -1 || skerr)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200271 ret = -1;
272 else
273 ret = send(fd, b->w, max, MSG_DONTWAIT);
274 }
275#else
276 ret = send(fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL);
277#endif
278
279 if (ret > 0) {
280 b->l -= ret;
281 b->w += ret;
282
Willy Tarreau0f9f5052006-07-29 17:39:25 +0200283 b->flags |= BF_PARTIAL_WRITE;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200284
285 if (b->w == b->data + BUFSIZE) {
286 b->w = b->data; /* wrap around the buffer */
287 }
Willy Tarreau83749182007-04-15 20:56:27 +0200288
Willy Tarreau6996e152007-04-30 14:37:43 +0200289 if (!b->l) {
290 EV_FD_CLR(fd, DIR_WR);
291 goto out_eternity;
292 }
Willy Tarreau83749182007-04-15 20:56:27 +0200293
Willy Tarreau6996e152007-04-30 14:37:43 +0200294 if (--write_poll <= 0)
295 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200296 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200297 else if (ret == 0 || errno == EAGAIN) {
298 /* nothing written, just pretend we were never called
299 * and wait for the socket to be ready. But we may have
300 * done some work justifying to notify the task.
301 */
Willy Tarreau83749182007-04-15 20:56:27 +0200302 retval = 0;
303 break;
304 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200305 else {
Willy Tarreau6996e152007-04-30 14:37:43 +0200306 goto out_error;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200307 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200308 } /* while (1) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200309
Willy Tarreau6996e152007-04-30 14:37:43 +0200310 /*
311 * The only way to get out of this loop is to have stopped writing
312 * without any error, either by limiting the number of loops, or
313 * because of an EAGAIN. We only rearm the timer if we have at least
314 * written something.
315 */
316
317 if (b->flags & BF_PARTIAL_WRITE) {
Willy Tarreau83749182007-04-15 20:56:27 +0200318 if (b->wto) {
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200319 tv_ms_add(&b->wex, &now, b->wto);
Willy Tarreau83749182007-04-15 20:56:27 +0200320 /* FIXME: to prevent the client from expiring read timeouts during writes,
321 * we refresh it. A solution would be to merge read+write timeouts into a
322 * unique one, although that needs some study particularly on full-duplex
323 * TCP connections. */
324 b->rex = b->wex;
Willy Tarreau6996e152007-04-30 14:37:43 +0200325 goto out_wakeup;
Willy Tarreau83749182007-04-15 20:56:27 +0200326 }
Willy Tarreau6996e152007-04-30 14:37:43 +0200327 out_eternity:
328 tv_eternity(&b->wex);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200329 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200330
Willy Tarreau6996e152007-04-30 14:37:43 +0200331 out_wakeup:
332 if (b->flags & BF_WRITE_STATUS)
333 task_wakeup(fdtab[fd].owner);
Willy Tarreau83749182007-04-15 20:56:27 +0200334 fdtab[fd].ev &= ~FD_POLL_WR;
335 return retval;
Willy Tarreau6996e152007-04-30 14:37:43 +0200336
337 out_error:
338 /* There was an error. we must wakeup the task. No need to clear
339 * the events, the task will do it.
340 */
341 fdtab[fd].state = FD_STERROR;
342 b->flags |= BF_WRITE_ERROR;
343 goto out_eternity;
344
345
Willy Tarreaubaaee002006-06-26 02:48:02 +0200346}
347
Willy Tarreaubaaee002006-06-26 02:48:02 +0200348
349
350/*
351 * Local variables:
352 * c-indent-level: 8
353 * c-basic-offset: 8
354 * End:
355 */