Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Functions operating on SOCK_STREAM and buffers. |
| 3 | * |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 4 | * Copyright 2000-2008 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 5 | * |
| 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 Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 22 | #include <common/compat.h> |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 23 | #include <common/config.h> |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 24 | #include <common/debug.h> |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 25 | #include <common/standard.h> |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 26 | #include <common/ticks.h> |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 27 | #include <common/time.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 28 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 29 | #include <types/buffers.h> |
| 30 | #include <types/global.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 31 | #include <types/polling.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 32 | |
| 33 | #include <proto/client.h> |
| 34 | #include <proto/fd.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 35 | #include <proto/stream_sock.h> |
| 36 | #include <proto/task.h> |
| 37 | |
| 38 | |
| 39 | /* |
Willy Tarreau | d797128 | 2006-07-29 18:36:34 +0200 | [diff] [blame] | 40 | * this function is called on a read event from a stream socket. |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 41 | * It returns 0 if we have a high confidence that we will not be |
| 42 | * able to read more data without polling first. Returns non-zero |
| 43 | * otherwise. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 44 | */ |
Willy Tarreau | d797128 | 2006-07-29 18:36:34 +0200 | [diff] [blame] | 45 | int stream_sock_read(int fd) { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 46 | __label__ out_wakeup, out_shutdown_r, out_error; |
Willy Tarreau | 5446940 | 2006-07-29 16:59:06 +0200 | [diff] [blame] | 47 | struct buffer *b = fdtab[fd].cb[DIR_RD].b; |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 48 | int ret, max, retval, cur_read; |
Willy Tarreau | b8949f1 | 2007-03-23 22:39:59 +0100 | [diff] [blame] | 49 | int read_poll = MAX_READ_POLL_LOOPS; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 50 | |
| 51 | #ifdef DEBUG_FULL |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 52 | fprintf(stderr,"stream_sock_read : fd=%d, ev=0x%02x, owner=%p\n", fd, fdtab[fd].ev, fdtab[fd].owner); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 53 | #endif |
| 54 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 55 | retval = 1; |
| 56 | |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 57 | /* stop immediately on errors */ |
| 58 | if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 59 | goto out_error; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 60 | |
| 61 | /* stop here if we reached the end of data */ |
| 62 | if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP) |
| 63 | goto out_shutdown_r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 64 | |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 65 | cur_read = 0; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 66 | while (1) { |
| 67 | /* |
| 68 | * 1. compute the maximum block size we can read at once. |
| 69 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 70 | if (b->l == 0) { /* let's realign the buffer to optimize I/O */ |
| 71 | b->r = b->w = b->lr = b->data; |
| 72 | max = b->rlim - b->data; |
| 73 | } |
| 74 | else if (b->r > b->w) { |
| 75 | max = b->rlim - b->r; |
| 76 | } |
| 77 | else { |
| 78 | max = b->w - b->r; |
| 79 | /* FIXME: theorically, if w>0, we shouldn't have rlim < data+size anymore |
| 80 | * since it means that the rewrite protection has been removed. This |
| 81 | * implies that the if statement can be removed. |
| 82 | */ |
| 83 | if (max > b->rlim - b->data) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 84 | max = b->rlim - b->data; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 85 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 86 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 87 | if (unlikely(max == 0)) { |
| 88 | /* Not anymore room to store data. This should theorically |
| 89 | * never happen, but better safe than sorry ! |
| 90 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 91 | EV_FD_CLR(fd, DIR_RD); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 92 | b->rex = TICK_ETERNITY; |
| 93 | goto out_wakeup; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 94 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 95 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 96 | /* |
| 97 | * 2. read the largest possible block |
| 98 | */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 99 | #ifndef MSG_NOSIGNAL |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 100 | { |
| 101 | int skerr; |
| 102 | socklen_t lskerr = sizeof(skerr); |
| 103 | |
| 104 | ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
| 105 | if (ret == -1 || skerr) |
| 106 | ret = -1; |
| 107 | else |
| 108 | ret = recv(fd, b->r, max, 0); |
| 109 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 110 | #else |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 111 | ret = recv(fd, b->r, max, MSG_NOSIGNAL); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 112 | #endif |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 113 | if (ret > 0) { |
| 114 | b->r += ret; |
| 115 | b->l += ret; |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 116 | cur_read += ret; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 117 | b->flags |= BF_PARTIAL_READ; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 118 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 119 | if (b->r == b->data + BUFSIZE) { |
| 120 | b->r = b->data; /* wrap around the buffer */ |
| 121 | } |
Willy Tarreau | 9641e8f | 2007-03-23 23:02:09 +0100 | [diff] [blame] | 122 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 123 | b->total += ret; |
Willy Tarreau | 9641e8f | 2007-03-23 23:02:09 +0100 | [diff] [blame] | 124 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 125 | if (b->l == b->rlim - b->data) { |
| 126 | /* The buffer is now full, there's no point in going through |
| 127 | * the loop again. |
| 128 | */ |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 129 | if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) { |
| 130 | b->xfer_small = 0; |
| 131 | b->xfer_large++; |
| 132 | if (b->xfer_large >= 3) { |
| 133 | /* we call this buffer a fast streamer if it manages |
| 134 | * to be filled in one call 3 consecutive times. |
| 135 | */ |
| 136 | b->flags |= (BF_STREAMER | BF_STREAMER_FAST); |
| 137 | //fputc('+', stderr); |
| 138 | } |
| 139 | } |
| 140 | else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) && |
| 141 | (cur_read <= BUFSIZE / 2)) { |
| 142 | b->xfer_large = 0; |
| 143 | b->xfer_small++; |
| 144 | if (b->xfer_small >= 2) { |
| 145 | /* if the buffer has been at least half full twice, |
| 146 | * we receive faster than we send, so at least it |
| 147 | * is not a "fast streamer". |
| 148 | */ |
| 149 | b->flags &= ~BF_STREAMER_FAST; |
| 150 | //fputc('-', stderr); |
| 151 | } |
| 152 | } |
| 153 | else { |
| 154 | b->xfer_small = 0; |
| 155 | b->xfer_large = 0; |
| 156 | } |
| 157 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 158 | EV_FD_CLR(fd, DIR_RD); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 159 | b->rex = TICK_ETERNITY; |
| 160 | goto out_wakeup; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 161 | } |
| 162 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 163 | /* if too many bytes were missing from last read, it means that |
| 164 | * it's pointless trying to read again because the system does |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 165 | * not have them in buffers. BTW, if FD_POLL_HUP was present, |
| 166 | * it means that we have reached the end and that the connection |
| 167 | * is closed. |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 168 | */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 169 | if (ret < max) { |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 170 | if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) && |
| 171 | (cur_read <= BUFSIZE / 2)) { |
| 172 | b->xfer_large = 0; |
| 173 | b->xfer_small++; |
| 174 | if (b->xfer_small >= 3) { |
| 175 | /* we have read less than half of the buffer in |
| 176 | * one pass, and this happened at least 3 times. |
| 177 | * This is definitely not a streamer. |
| 178 | */ |
| 179 | b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST); |
| 180 | //fputc('!', stderr); |
| 181 | } |
| 182 | } |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 183 | if (fdtab[fd].ev & FD_POLL_HUP) |
| 184 | goto out_shutdown_r; |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 185 | break; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 186 | } |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 187 | |
| 188 | /* generally if we read something smaller than 1 or 2 MSS, |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 189 | * it means that it's not worth trying to read again. It may |
| 190 | * also happen on headers, but the application then can stop |
| 191 | * reading before we start polling. |
| 192 | */ |
| 193 | if (ret < MIN_RET_FOR_READ_LOOP) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 194 | break; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 195 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 196 | if (--read_poll <= 0) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 197 | break; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 198 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 199 | } |
| 200 | else if (ret == 0) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 201 | /* connection closed */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 202 | goto out_shutdown_r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 203 | } |
Willy Tarreau | 9f19529 | 2007-04-15 21:26:58 +0200 | [diff] [blame] | 204 | else if (errno == EAGAIN) { |
| 205 | /* Ignore EAGAIN but inform the poller that there is |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 206 | * nothing to read left. But we may have done some work |
| 207 | * justifying to notify the task. |
Willy Tarreau | 9f19529 | 2007-04-15 21:26:58 +0200 | [diff] [blame] | 208 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 209 | retval = 0; |
| 210 | break; |
| 211 | } |
| 212 | else { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 213 | goto out_error; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 214 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 215 | } /* while (1) */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 216 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 217 | /* |
| 218 | * The only way to get out of this loop is to have stopped reading |
| 219 | * without any error nor close, either by limiting the number of |
| 220 | * loops, or because of an EAGAIN. We only rearm the timer if we |
| 221 | * have at least read something. |
| 222 | */ |
| 223 | |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 224 | if (b->flags & BF_PARTIAL_READ) |
| 225 | b->rex = tick_add_ifset(now_ms, b->rto); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 226 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 227 | out_wakeup: |
| 228 | if (b->flags & BF_READ_STATUS) |
| 229 | task_wakeup(fdtab[fd].owner); |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 230 | fdtab[fd].ev &= ~FD_POLL_IN; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 231 | return retval; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 232 | |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 233 | out_shutdown_r: |
| 234 | fdtab[fd].ev &= ~FD_POLL_HUP; |
| 235 | b->flags |= BF_READ_NULL; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 236 | b->rex = TICK_ETERNITY; |
| 237 | goto out_wakeup; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 238 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 239 | out_error: |
| 240 | /* There was an error. we must wakeup the task. No need to clear |
| 241 | * the events, the task will do it. |
| 242 | */ |
| 243 | fdtab[fd].state = FD_STERROR; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 244 | fdtab[fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 245 | b->flags |= BF_READ_ERROR; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 246 | b->rex = TICK_ETERNITY; |
| 247 | goto out_wakeup; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | |
| 251 | /* |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 252 | * this function is called on a write event from a stream socket. |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 253 | * It returns 0 if we have a high confidence that we will not be |
| 254 | * able to write more data without polling first. Returns non-zero |
| 255 | * otherwise. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 256 | */ |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 257 | int stream_sock_write(int fd) { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 258 | __label__ out_wakeup, out_error; |
Willy Tarreau | 5446940 | 2006-07-29 16:59:06 +0200 | [diff] [blame] | 259 | struct buffer *b = fdtab[fd].cb[DIR_WR].b; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 260 | int ret, max, retval; |
| 261 | int write_poll = MAX_WRITE_POLL_LOOPS; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 262 | |
| 263 | #ifdef DEBUG_FULL |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 264 | fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 265 | #endif |
| 266 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 267 | retval = 1; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 268 | if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 269 | goto out_error; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 270 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 271 | while (1) { |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 272 | if (b->l == 0) { /* let's realign the buffer to optimize I/O */ |
| 273 | b->r = b->w = b->lr = b->data; |
| 274 | max = 0; |
| 275 | } |
| 276 | else if (b->r > b->w) { |
| 277 | max = b->r - b->w; |
| 278 | } |
| 279 | else { |
| 280 | max = b->data + BUFSIZE - b->w; |
| 281 | } |
| 282 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 283 | if (max == 0) { |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 284 | /* may be we have received a connection acknowledgement in TCP mode without data */ |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 285 | if (likely(fdtab[fd].state == FD_STCONN)) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 286 | /* We have no data to send to check the connection, and |
| 287 | * getsockopt() will not inform us whether the connection |
| 288 | * is still pending. So we'll reuse connect() to check the |
| 289 | * state of the socket. This has the advantage of givig us |
| 290 | * the following info : |
| 291 | * - error |
| 292 | * - connecting (EALREADY, EINPROGRESS) |
| 293 | * - connected (EISCONN, 0) |
| 294 | */ |
Willy Tarreau | e94ebd0 | 2007-10-09 17:14:37 +0200 | [diff] [blame] | 295 | if ((connect(fd, fdtab[fd].peeraddr, fdtab[fd].peerlen) == 0)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 296 | errno = 0; |
| 297 | |
| 298 | if (errno == EALREADY || errno == EINPROGRESS) { |
| 299 | retval = 0; |
| 300 | goto out_wakeup; |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 301 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 302 | |
| 303 | if (errno && errno != EISCONN) |
| 304 | goto out_error; |
| 305 | |
| 306 | /* OK we just need to indicate that we got a connection |
| 307 | * and that we wrote nothing. |
| 308 | */ |
| 309 | b->flags |= BF_WRITE_NULL; |
| 310 | fdtab[fd].state = FD_STREADY; |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 311 | } |
| 312 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 313 | /* Funny, we were called to write something but there wasn't |
| 314 | * anything. Theorically we cannot get there, but just in case, |
| 315 | * let's disable the write event and pretend we never came there. |
| 316 | */ |
Willy Tarreau | f161a34 | 2007-04-08 16:59:42 +0200 | [diff] [blame] | 317 | EV_FD_CLR(fd, DIR_WR); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 318 | b->wex = TICK_ETERNITY; |
| 319 | goto out_wakeup; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | #ifndef MSG_NOSIGNAL |
| 323 | { |
| 324 | int skerr; |
| 325 | socklen_t lskerr = sizeof(skerr); |
| 326 | |
Willy Tarreau | c642348 | 2006-10-15 14:59:03 +0200 | [diff] [blame] | 327 | ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
| 328 | if (ret == -1 || skerr) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 329 | ret = -1; |
| 330 | else |
| 331 | ret = send(fd, b->w, max, MSG_DONTWAIT); |
| 332 | } |
| 333 | #else |
| 334 | ret = send(fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL); |
| 335 | #endif |
| 336 | |
| 337 | if (ret > 0) { |
| 338 | b->l -= ret; |
| 339 | b->w += ret; |
| 340 | |
Willy Tarreau | 0f9f505 | 2006-07-29 17:39:25 +0200 | [diff] [blame] | 341 | b->flags |= BF_PARTIAL_WRITE; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 342 | |
| 343 | if (b->w == b->data + BUFSIZE) { |
| 344 | b->w = b->data; /* wrap around the buffer */ |
| 345 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 346 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 347 | if (!b->l) { |
| 348 | EV_FD_CLR(fd, DIR_WR); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 349 | b->wex = TICK_ETERNITY; |
| 350 | goto out_wakeup; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 351 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 352 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 353 | /* if the system buffer is full, don't insist */ |
| 354 | if (ret < max) |
| 355 | break; |
| 356 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 357 | if (--write_poll <= 0) |
| 358 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 359 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 360 | else if (ret == 0 || errno == EAGAIN) { |
| 361 | /* nothing written, just pretend we were never called |
| 362 | * and wait for the socket to be ready. But we may have |
| 363 | * done some work justifying to notify the task. |
| 364 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 365 | retval = 0; |
| 366 | break; |
| 367 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 368 | else { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 369 | goto out_error; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 370 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 371 | } /* while (1) */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 372 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 373 | /* |
| 374 | * The only way to get out of this loop is to have stopped writing |
| 375 | * without any error, either by limiting the number of loops, or |
| 376 | * because of an EAGAIN. We only rearm the timer if we have at least |
| 377 | * written something. |
| 378 | */ |
| 379 | |
| 380 | if (b->flags & BF_PARTIAL_WRITE) { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 381 | b->wex = tick_add_ifset(now_ms, b->wto); |
| 382 | if (b->wex) { |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 383 | /* FIXME: to prevent the client from expiring read timeouts during writes, |
| 384 | * we refresh it. A solution would be to merge read+write timeouts into a |
| 385 | * unique one, although that needs some study particularly on full-duplex |
| 386 | * TCP connections. */ |
Willy Tarreau | fa64558 | 2007-06-03 15:59:52 +0200 | [diff] [blame] | 387 | if (!(b->flags & BF_SHUTR_STATUS)) |
| 388 | b->rex = b->wex; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 389 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 390 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 391 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 392 | out_wakeup: |
| 393 | if (b->flags & BF_WRITE_STATUS) |
| 394 | task_wakeup(fdtab[fd].owner); |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 395 | fdtab[fd].ev &= ~FD_POLL_OUT; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 396 | return retval; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 397 | |
| 398 | out_error: |
| 399 | /* There was an error. we must wakeup the task. No need to clear |
| 400 | * the events, the task will do it. |
| 401 | */ |
| 402 | fdtab[fd].state = FD_STERROR; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 403 | fdtab[fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 404 | b->flags |= BF_WRITE_ERROR; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 405 | b->wex = TICK_ETERNITY; |
| 406 | goto out_wakeup; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 407 | } |
| 408 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 409 | |
| 410 | |
| 411 | /* |
| 412 | * Local variables: |
| 413 | * c-indent-level: 8 |
| 414 | * c-basic-offset: 8 |
| 415 | * End: |
| 416 | */ |