2
* Functions operating on SOCK_STREAM and buffers.
4
* Copyright 2000-2007 Willy Tarreau <w@1wt.eu>
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.
18
#include <sys/socket.h>
20
#include <sys/types.h>
22
#include <common/compat.h>
23
#include <common/config.h>
24
#include <common/standard.h>
25
#include <common/time.h>
27
#include <types/buffers.h>
28
#include <types/global.h>
29
#include <types/polling.h>
30
#include <types/session.h>
32
#include <proto/client.h>
34
#include <proto/stream_sock.h>
35
#include <proto/task.h>
39
* this function is called on a read event from a stream socket.
40
* 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
44
int stream_sock_read(int fd) {
45
__label__ out_eternity, out_wakeup, out_error;
46
struct buffer *b = fdtab[fd].cb[DIR_RD].b;
48
int read_poll = MAX_READ_POLL_LOOPS;
51
fprintf(stderr,"stream_sock_read : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
56
if (unlikely(fdtab[fd].ev & FD_POLL_HUP)) {
57
/* connection closed */
58
b->flags |= BF_READ_NULL;
61
else if (unlikely(fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR))) {
67
* 1. compute the maximum block size we can read at once.
69
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;
73
else if (b->r > b->w) {
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.
82
if (max > b->rlim - b->data)
83
max = b->rlim - b->data;
86
if (unlikely(max == 0)) {
87
/* Not anymore room to store data. This should theorically
88
* never happen, but better safe than sorry !
90
EV_FD_CLR(fd, DIR_RD);
95
* 2. read the largest possible block
100
socklen_t lskerr = sizeof(skerr);
102
ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
103
if (ret == -1 || skerr)
106
ret = recv(fd, b->r, max, 0);
109
ret = recv(fd, b->r, max, MSG_NOSIGNAL);
114
b->flags |= BF_PARTIAL_READ;
116
if (b->r == b->data + BUFSIZE) {
117
b->r = b->data; /* wrap around the buffer */
122
if (b->l == b->rlim - b->data) {
123
/* The buffer is now full, there's no point in going through
126
EV_FD_CLR(fd, DIR_RD);
130
/* if too many bytes were missing from last read, it means that
131
* it's pointless trying to read again because the system does
132
* not have them in buffers.
137
/* generally if we read something smaller than 1 or 2 MSS,
138
* it means that it's not worth trying to read again. It may
139
* also happen on headers, but the application then can stop
140
* reading before we start polling.
142
if (ret < MIN_RET_FOR_READ_LOOP)
145
if (--read_poll <= 0)
150
/* connection closed */
151
b->flags |= BF_READ_NULL;
154
else if (errno == EAGAIN) {
155
/* Ignore EAGAIN but inform the poller that there is
156
* nothing to read left. But we may have done some work
157
* justifying to notify the task.
168
* The only way to get out of this loop is to have stopped reading
169
* without any error nor close, either by limiting the number of
170
* loops, or because of an EAGAIN. We only rearm the timer if we
171
* have at least read something.
174
if (b->flags & BF_PARTIAL_READ) {
175
if (tv_add_ifset(&b->rex, &now, &b->rto))
178
tv_eternity(&b->rex);
182
if (b->flags & BF_READ_STATUS)
183
task_wakeup(fdtab[fd].owner);
184
fdtab[fd].ev &= ~FD_POLL_RD;
188
/* There was an error. we must wakeup the task. No need to clear
189
* the events, the task will do it.
191
fdtab[fd].state = FD_STERROR;
192
b->flags |= BF_READ_ERROR;
198
* this function is called on a write event from a stream socket.
199
* It returns 0 if we have a high confidence that we will not be
200
* able to write more data without polling first. Returns non-zero
203
int stream_sock_write(int fd) {
204
__label__ out_eternity, out_wakeup, out_error;
205
struct buffer *b = fdtab[fd].cb[DIR_WR].b;
206
int ret, max, retval;
207
int write_poll = MAX_WRITE_POLL_LOOPS;
210
fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner);
214
if (unlikely(fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)))
218
if (b->l == 0) { /* let's realign the buffer to optimize I/O */
219
b->r = b->w = b->lr = b->data;
222
else if (b->r > b->w) {
226
max = b->data + BUFSIZE - b->w;
230
/* may be we have received a connection acknowledgement in TCP mode without data */
231
if (likely(fdtab[fd].state == FD_STCONN)) {
232
struct session *s = fdtab[fd].owner->context;
234
/* We have no data to send to check the connection, and
235
* getsockopt() will not inform us whether the connection
236
* is still pending. So we'll reuse connect() to check the
237
* state of the socket. This has the advantage of givig us
238
* the following info :
240
* - connecting (EALREADY, EINPROGRESS)
241
* - connected (EISCONN, 0)
243
if ((connect(fd, (struct sockaddr *)&s->srv_addr, sizeof(s->srv_addr)) == 0))
246
if (errno == EALREADY || errno == EINPROGRESS) {
251
if (errno && errno != EISCONN)
254
/* OK we just need to indicate that we got a connection
255
* and that we wrote nothing.
257
b->flags |= BF_WRITE_NULL;
258
fdtab[fd].state = FD_STREADY;
261
/* Funny, we were called to write something but there wasn't
262
* anything. Theorically we cannot get there, but just in case,
263
* let's disable the write event and pretend we never came there.
265
EV_FD_CLR(fd, DIR_WR);
272
socklen_t lskerr = sizeof(skerr);
274
ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
275
if (ret == -1 || skerr)
278
ret = send(fd, b->w, max, MSG_DONTWAIT);
281
ret = send(fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL);
288
b->flags |= BF_PARTIAL_WRITE;
290
if (b->w == b->data + BUFSIZE) {
291
b->w = b->data; /* wrap around the buffer */
295
EV_FD_CLR(fd, DIR_WR);
299
/* if the system buffer is full, don't insist */
303
if (--write_poll <= 0)
306
else if (ret == 0 || errno == EAGAIN) {
307
/* nothing written, just pretend we were never called
308
* and wait for the socket to be ready. But we may have
309
* done some work justifying to notify the task.
320
* The only way to get out of this loop is to have stopped writing
321
* without any error, either by limiting the number of loops, or
322
* because of an EAGAIN. We only rearm the timer if we have at least
326
if (b->flags & BF_PARTIAL_WRITE) {
327
if (tv_add_ifset(&b->wex, &now, &b->wto)) {
328
/* FIXME: to prevent the client from expiring read timeouts during writes,
329
* we refresh it. A solution would be to merge read+write timeouts into a
330
* unique one, although that needs some study particularly on full-duplex
331
* TCP connections. */
332
if (!(b->flags & BF_SHUTR_STATUS))
337
tv_eternity(&b->wex);
341
if (b->flags & BF_WRITE_STATUS)
342
task_wakeup(fdtab[fd].owner);
343
fdtab[fd].ev &= ~FD_POLL_WR;
347
/* There was an error. we must wakeup the task. No need to clear
348
* the events, the task will do it.
350
fdtab[fd].state = FD_STERROR;
351
b->flags |= BF_WRITE_ERROR;
added
removed
src/stream_sock.c
