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 | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 29 | #include <proto/buffers.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 30 | #include <proto/client.h> |
| 31 | #include <proto/fd.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 32 | #include <proto/stream_sock.h> |
| 33 | #include <proto/task.h> |
| 34 | |
| 35 | |
| 36 | /* |
Willy Tarreau | d797128 | 2006-07-29 18:36:34 +0200 | [diff] [blame] | 37 | * this function is called on a read event from a stream socket. |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 38 | * It returns 0 if we have a high confidence that we will not be |
| 39 | * able to read more data without polling first. Returns non-zero |
| 40 | * otherwise. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 41 | */ |
Willy Tarreau | d797128 | 2006-07-29 18:36:34 +0200 | [diff] [blame] | 42 | int stream_sock_read(int fd) { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 43 | __label__ out_wakeup, out_shutdown_r, out_error; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 44 | struct stream_interface *si = fdtab[fd].owner; |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 45 | struct buffer *b = si->ib; |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 46 | int ret, max, retval, cur_read; |
Willy Tarreau | b8949f1 | 2007-03-23 22:39:59 +0100 | [diff] [blame] | 47 | int read_poll = MAX_READ_POLL_LOOPS; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 48 | |
| 49 | #ifdef DEBUG_FULL |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 50 | 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] | 51 | #endif |
| 52 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 53 | retval = 1; |
| 54 | |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 55 | /* stop immediately on errors */ |
| 56 | if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 57 | goto out_error; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 58 | |
| 59 | /* stop here if we reached the end of data */ |
| 60 | if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP) |
| 61 | goto out_shutdown_r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 62 | |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 63 | cur_read = 0; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 64 | while (1) { |
| 65 | /* |
| 66 | * 1. compute the maximum block size we can read at once. |
| 67 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 68 | if (b->l == 0) { /* let's realign the buffer to optimize I/O */ |
| 69 | b->r = b->w = b->lr = b->data; |
| 70 | max = b->rlim - b->data; |
| 71 | } |
| 72 | else if (b->r > b->w) { |
| 73 | max = b->rlim - b->r; |
| 74 | } |
| 75 | else { |
| 76 | max = b->w - b->r; |
| 77 | /* FIXME: theorically, if w>0, we shouldn't have rlim < data+size anymore |
| 78 | * since it means that the rewrite protection has been removed. This |
| 79 | * implies that the if statement can be removed. |
| 80 | */ |
| 81 | if (max > b->rlim - b->data) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 82 | max = b->rlim - b->data; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 83 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 84 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 85 | if (unlikely(max == 0)) { |
| 86 | /* Not anymore room to store data. This should theorically |
| 87 | * never happen, but better safe than sorry ! |
| 88 | */ |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 89 | b->flags |= BF_FULL; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 90 | EV_FD_CLR(fd, DIR_RD); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 91 | b->rex = TICK_ETERNITY; |
| 92 | goto out_wakeup; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 93 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 94 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 95 | /* |
| 96 | * 2. read the largest possible block |
| 97 | */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 98 | #ifndef MSG_NOSIGNAL |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 99 | { |
| 100 | int skerr; |
| 101 | socklen_t lskerr = sizeof(skerr); |
| 102 | |
| 103 | ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
| 104 | if (ret == -1 || skerr) |
| 105 | ret = -1; |
| 106 | else |
| 107 | ret = recv(fd, b->r, max, 0); |
| 108 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 109 | #else |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 110 | ret = recv(fd, b->r, max, MSG_NOSIGNAL); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 111 | #endif |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 112 | if (ret > 0) { |
| 113 | b->r += ret; |
| 114 | b->l += ret; |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 115 | cur_read += ret; |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 116 | b->flags |= BF_READ_PARTIAL; |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 117 | b->flags &= ~BF_EMPTY; |
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 | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 125 | if (b->l >= b->rlim - b->data) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 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 | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 158 | b->flags |= BF_FULL; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 159 | EV_FD_CLR(fd, DIR_RD); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 160 | b->rex = TICK_ETERNITY; |
| 161 | goto out_wakeup; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 162 | } |
| 163 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 164 | /* if too many bytes were missing from last read, it means that |
| 165 | * it's pointless trying to read again because the system does |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 166 | * not have them in buffers. BTW, if FD_POLL_HUP was present, |
| 167 | * it means that we have reached the end and that the connection |
| 168 | * is closed. |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 169 | */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 170 | if (ret < max) { |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 171 | if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) && |
| 172 | (cur_read <= BUFSIZE / 2)) { |
| 173 | b->xfer_large = 0; |
| 174 | b->xfer_small++; |
| 175 | if (b->xfer_small >= 3) { |
| 176 | /* we have read less than half of the buffer in |
| 177 | * one pass, and this happened at least 3 times. |
| 178 | * This is definitely not a streamer. |
| 179 | */ |
| 180 | b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST); |
| 181 | //fputc('!', stderr); |
| 182 | } |
| 183 | } |
Willy Tarreau | 2bea3a1 | 2008-08-28 09:47:43 +0200 | [diff] [blame] | 184 | /* unfortunately, on level-triggered events, POLL_HUP |
| 185 | * is generally delivered AFTER the system buffer is |
| 186 | * empty, so this one might never match. |
| 187 | */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 188 | if (fdtab[fd].ev & FD_POLL_HUP) |
| 189 | goto out_shutdown_r; |
Willy Tarreau | 2bea3a1 | 2008-08-28 09:47:43 +0200 | [diff] [blame] | 190 | |
| 191 | /* if a streamer has read few data, it may be because we |
| 192 | * have exhausted system buffers. It's not worth trying |
| 193 | * again. |
| 194 | */ |
| 195 | if (b->flags & BF_STREAMER) |
| 196 | break; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 197 | } |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 198 | |
| 199 | /* generally if we read something smaller than 1 or 2 MSS, |
Willy Tarreau | 2bea3a1 | 2008-08-28 09:47:43 +0200 | [diff] [blame] | 200 | * it means that either we have exhausted the system's |
| 201 | * buffers (streamer or question-response protocol) or that |
| 202 | * the connection will be closed. Streamers are easily |
| 203 | * detected so we return early. For other cases, it's still |
| 204 | * better to perform a last read to be sure, because it may |
| 205 | * save one complete poll/read/wakeup cycle in case of shutdown. |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 206 | */ |
Willy Tarreau | 2bea3a1 | 2008-08-28 09:47:43 +0200 | [diff] [blame] | 207 | if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 208 | break; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 209 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 210 | if (--read_poll <= 0) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 211 | break; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 212 | } |
| 213 | else if (ret == 0) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 214 | /* connection closed */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 215 | goto out_shutdown_r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 216 | } |
Willy Tarreau | 9f19529 | 2007-04-15 21:26:58 +0200 | [diff] [blame] | 217 | else if (errno == EAGAIN) { |
| 218 | /* Ignore EAGAIN but inform the poller that there is |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 219 | * nothing to read left. But we may have done some work |
| 220 | * justifying to notify the task. |
Willy Tarreau | 9f19529 | 2007-04-15 21:26:58 +0200 | [diff] [blame] | 221 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 222 | retval = 0; |
| 223 | break; |
| 224 | } |
| 225 | else { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 226 | goto out_error; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 227 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 228 | } /* while (1) */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 229 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 230 | /* |
| 231 | * The only way to get out of this loop is to have stopped reading |
| 232 | * without any error nor close, either by limiting the number of |
| 233 | * loops, or because of an EAGAIN. We only rearm the timer if we |
| 234 | * have at least read something. |
| 235 | */ |
| 236 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 237 | if (tick_isset(b->rex) && b->flags & BF_READ_PARTIAL) |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 238 | b->rex = tick_add_ifset(now_ms, b->rto); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 239 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 240 | if (!(b->flags & BF_READ_ACTIVITY)) |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 241 | goto out_skip_wakeup; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 242 | out_wakeup: |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 243 | task_wakeup(si->owner, TASK_WOKEN_IO); |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 244 | |
| 245 | out_skip_wakeup: |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 246 | fdtab[fd].ev &= ~FD_POLL_IN; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 247 | return retval; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 248 | |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 249 | out_shutdown_r: |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 250 | /* we received a shutdown */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 251 | fdtab[fd].ev &= ~FD_POLL_HUP; |
| 252 | b->flags |= BF_READ_NULL; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 253 | buffer_shutr(b); |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 254 | |
| 255 | /* Maybe we have to completely close the local socket */ |
| 256 | if (si->ob->flags & BF_SHUTW) |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 257 | goto do_close_and_return; |
| 258 | EV_FD_CLR(fd, DIR_RD); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 259 | goto out_wakeup; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 260 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 261 | out_error: |
| 262 | /* There was an error. we must wakeup the task. No need to clear |
| 263 | * the events, the task will do it. |
| 264 | */ |
| 265 | fdtab[fd].state = FD_STERROR; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 266 | fdtab[fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 267 | b->rex = TICK_ETERNITY; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 268 | |
| 269 | /* Read error on the file descriptor. We close the FD and set |
| 270 | * the error on both buffers. |
| 271 | * Note: right now we only support connected sockets. |
| 272 | */ |
| 273 | if (si->state != SI_ST_EST) |
| 274 | goto out_wakeup; |
| 275 | |
| 276 | if (!si->err_type) |
| 277 | si->err_type = SI_ET_DATA_ERR; |
| 278 | |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 279 | buffer_shutr(b); |
| 280 | b->flags |= BF_READ_ERROR; |
| 281 | buffer_shutw(si->ob); |
| 282 | si->ob->flags |= BF_WRITE_ERROR; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 283 | |
| 284 | do_close_and_return: |
| 285 | fd_delete(fd); |
| 286 | si->state = SI_ST_CLO; |
| 287 | task_wakeup(si->owner, TASK_WOKEN_IO); |
| 288 | return 1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 289 | } |
| 290 | |
| 291 | |
| 292 | /* |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 293 | * this function is called on a write event from a stream socket. |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 294 | * It returns 0 if we have a high confidence that we will not be |
| 295 | * able to write more data without polling first. Returns non-zero |
| 296 | * otherwise. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 297 | */ |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 298 | int stream_sock_write(int fd) { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 299 | __label__ out_wakeup, out_error; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 300 | struct stream_interface *si = fdtab[fd].owner; |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 301 | struct buffer *b = si->ob; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 302 | int ret, max, retval; |
| 303 | int write_poll = MAX_WRITE_POLL_LOOPS; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 304 | |
| 305 | #ifdef DEBUG_FULL |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 306 | 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] | 307 | #endif |
| 308 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 309 | retval = 1; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 310 | if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 311 | goto out_error; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 312 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 313 | while (1) { |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 314 | if (b->l == 0) { /* let's realign the buffer to optimize I/O */ |
| 315 | b->r = b->w = b->lr = b->data; |
| 316 | max = 0; |
| 317 | } |
| 318 | else if (b->r > b->w) { |
| 319 | max = b->r - b->w; |
| 320 | } |
| 321 | else { |
| 322 | max = b->data + BUFSIZE - b->w; |
| 323 | } |
| 324 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 325 | if (max == 0) { |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 326 | /* 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] | 327 | if (likely(fdtab[fd].state == FD_STCONN)) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 328 | /* We have no data to send to check the connection, and |
| 329 | * getsockopt() will not inform us whether the connection |
| 330 | * is still pending. So we'll reuse connect() to check the |
| 331 | * state of the socket. This has the advantage of givig us |
| 332 | * the following info : |
| 333 | * - error |
| 334 | * - connecting (EALREADY, EINPROGRESS) |
| 335 | * - connected (EISCONN, 0) |
| 336 | */ |
Willy Tarreau | e94ebd0 | 2007-10-09 17:14:37 +0200 | [diff] [blame] | 337 | if ((connect(fd, fdtab[fd].peeraddr, fdtab[fd].peerlen) == 0)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 338 | errno = 0; |
| 339 | |
| 340 | if (errno == EALREADY || errno == EINPROGRESS) { |
| 341 | retval = 0; |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 342 | goto out_may_wakeup; |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 343 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 344 | |
| 345 | if (errno && errno != EISCONN) |
| 346 | goto out_error; |
| 347 | |
| 348 | /* OK we just need to indicate that we got a connection |
| 349 | * and that we wrote nothing. |
| 350 | */ |
| 351 | b->flags |= BF_WRITE_NULL; |
| 352 | fdtab[fd].state = FD_STREADY; |
Willy Tarreau | f8306d5 | 2006-07-29 19:01:31 +0200 | [diff] [blame] | 353 | } |
| 354 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 355 | /* Funny, we were called to write something but there wasn't |
| 356 | * anything. Theorically we cannot get there, but just in case, |
| 357 | * let's disable the write event and pretend we never came there. |
| 358 | */ |
Willy Tarreau | f161a34 | 2007-04-08 16:59:42 +0200 | [diff] [blame] | 359 | EV_FD_CLR(fd, DIR_WR); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 360 | b->wex = TICK_ETERNITY; |
| 361 | goto out_wakeup; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 362 | } |
| 363 | |
| 364 | #ifndef MSG_NOSIGNAL |
| 365 | { |
| 366 | int skerr; |
| 367 | socklen_t lskerr = sizeof(skerr); |
| 368 | |
Willy Tarreau | c642348 | 2006-10-15 14:59:03 +0200 | [diff] [blame] | 369 | ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
| 370 | if (ret == -1 || skerr) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 371 | ret = -1; |
| 372 | else |
| 373 | ret = send(fd, b->w, max, MSG_DONTWAIT); |
| 374 | } |
| 375 | #else |
| 376 | ret = send(fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL); |
| 377 | #endif |
| 378 | |
| 379 | if (ret > 0) { |
| 380 | b->l -= ret; |
| 381 | b->w += ret; |
| 382 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 383 | b->flags |= BF_WRITE_PARTIAL; |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 384 | |
| 385 | if (b->l < b->rlim - b->data) |
| 386 | b->flags &= ~BF_FULL; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 387 | |
| 388 | if (b->w == b->data + BUFSIZE) { |
| 389 | b->w = b->data; /* wrap around the buffer */ |
| 390 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 391 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 392 | if (!b->l) { |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 393 | b->flags |= BF_EMPTY; |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 394 | |
| 395 | /* Maybe we just wrote the last chunk and need to close ? */ |
| 396 | if ((b->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) == (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) { |
| 397 | if (si->state == SI_ST_EST) { |
| 398 | buffer_shutw(b); |
| 399 | if (si->ib->flags & BF_SHUTR) |
| 400 | goto do_close_and_return; |
| 401 | shutdown(fd, SHUT_WR); |
| 402 | } |
| 403 | } |
| 404 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 405 | EV_FD_CLR(fd, DIR_WR); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 406 | b->wex = TICK_ETERNITY; |
| 407 | goto out_wakeup; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 408 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 409 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 410 | /* if the system buffer is full, don't insist */ |
| 411 | if (ret < max) |
| 412 | break; |
| 413 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 414 | if (--write_poll <= 0) |
| 415 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 416 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 417 | else if (ret == 0 || errno == EAGAIN) { |
| 418 | /* nothing written, just pretend we were never called |
| 419 | * and wait for the socket to be ready. But we may have |
| 420 | * done some work justifying to notify the task. |
| 421 | */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 422 | retval = 0; |
| 423 | break; |
| 424 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 425 | else { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 426 | goto out_error; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 427 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 428 | } /* while (1) */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 429 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 430 | /* |
| 431 | * The only way to get out of this loop is to have stopped writing |
| 432 | * without any error, either by limiting the number of loops, or |
| 433 | * because of an EAGAIN. We only rearm the timer if we have at least |
| 434 | * written something. |
| 435 | */ |
| 436 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 437 | if (tick_isset(b->wex) && b->flags & BF_WRITE_PARTIAL) { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 438 | b->wex = tick_add_ifset(now_ms, b->wto); |
Willy Tarreau | adfb856 | 2008-08-11 15:24:42 +0200 | [diff] [blame] | 439 | if (tick_isset(b->wex)) { |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 440 | /* FIXME: to prevent the client from expiring read timeouts during writes, |
| 441 | * we refresh it. A solution would be to merge read+write timeouts into a |
| 442 | * unique one, although that needs some study particularly on full-duplex |
| 443 | * TCP connections. */ |
Willy Tarreau | ba392ce | 2008-08-16 21:13:23 +0200 | [diff] [blame] | 444 | if (tick_isset(b->rex) && !(b->flags & BF_SHUTR)) |
Willy Tarreau | fa64558 | 2007-06-03 15:59:52 +0200 | [diff] [blame] | 445 | b->rex = b->wex; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 446 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 447 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 448 | |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 449 | out_may_wakeup: |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 450 | if (!(b->flags & BF_WRITE_ACTIVITY)) |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 451 | goto out_skip_wakeup; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 452 | out_wakeup: |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 453 | task_wakeup(si->owner, TASK_WOKEN_IO); |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 454 | |
| 455 | out_skip_wakeup: |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 456 | fdtab[fd].ev &= ~FD_POLL_OUT; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 457 | return retval; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 458 | |
| 459 | out_error: |
| 460 | /* There was an error. we must wakeup the task. No need to clear |
| 461 | * the events, the task will do it. |
| 462 | */ |
| 463 | fdtab[fd].state = FD_STERROR; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 464 | fdtab[fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 465 | b->wex = TICK_ETERNITY; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 466 | /* Read error on the file descriptor. We close the FD and set |
| 467 | * the error on both buffers. |
| 468 | * Note: right now we only support connected sockets. |
| 469 | */ |
| 470 | if (si->state != SI_ST_EST) |
| 471 | goto out_wakeup; |
| 472 | |
| 473 | if (!si->err_type) |
| 474 | si->err_type = SI_ET_DATA_ERR; |
| 475 | |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 476 | buffer_shutw(b); |
| 477 | b->flags |= BF_WRITE_ERROR; |
| 478 | buffer_shutr(si->ib); |
| 479 | si->ib->flags |= BF_READ_ERROR; |
| 480 | do_close_and_return: |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 481 | fd_delete(fd); |
| 482 | si->state = SI_ST_CLO; |
| 483 | task_wakeup(si->owner, TASK_WOKEN_IO); |
| 484 | return 1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 485 | } |
| 486 | |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 487 | /* |
| 488 | * This function performs a shutdown-write on a stream interface in a connected |
| 489 | * state (it does nothing for other states). It either shuts the write side or |
| 490 | * closes the file descriptor and marks itself as closed. No buffer flags are |
| 491 | * changed, it's up to the caller to adjust them. The sole purpose of this |
| 492 | * function is to be called from the other stream interface to notify of a |
| 493 | * close_read, or by itself upon a full write leading to an empty buffer. |
| 494 | * It normally returns zero, unless it has completely closed the socket, in |
| 495 | * which case it returns 1. |
| 496 | */ |
| 497 | int stream_sock_shutw(struct stream_interface *si) |
| 498 | { |
| 499 | if (si->state != SI_ST_EST) |
| 500 | return 0; |
| 501 | |
| 502 | if (si->ib->flags & BF_SHUTR) { |
| 503 | fd_delete(si->fd); |
| 504 | si->state = SI_ST_CLO; |
| 505 | return 1; |
| 506 | } |
| 507 | EV_FD_CLR(si->fd, DIR_WR); |
| 508 | shutdown(si->fd, SHUT_WR); |
| 509 | return 0; |
| 510 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 511 | |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 512 | /* |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 513 | * This function only has to be called once after a wakeup event during a data |
| 514 | * phase. It controls the file descriptor's status, as well as read and write |
| 515 | * timeouts. |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 516 | */ |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 517 | int stream_sock_data_check_timeouts(int fd) |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 518 | { |
| 519 | struct buffer *ib = fdtab[fd].cb[DIR_RD].b; |
| 520 | struct buffer *ob = fdtab[fd].cb[DIR_WR].b; |
| 521 | |
| 522 | DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d\n", |
| 523 | now_ms, __FUNCTION__, |
| 524 | fd, fdtab[fd].owner, |
| 525 | ib, ob, |
| 526 | ib->rex, ob->wex, |
| 527 | ib->flags, ob->flags, |
| 528 | ib->l, ob->l); |
| 529 | |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 530 | /* Read timeout */ |
| 531 | if (unlikely(!(ib->flags & (BF_SHUTR|BF_READ_TIMEOUT)) && tick_is_expired(ib->rex, now_ms))) { |
| 532 | //trace_term(t, TT_HTTP_SRV_12); |
| 533 | ib->flags |= BF_READ_TIMEOUT; |
| 534 | if (!ob->cons->err_type) { |
| 535 | //ob->cons->err_loc = t->srv; |
| 536 | ob->cons->err_type = SI_ET_DATA_TO; |
| 537 | } |
| 538 | buffer_shutr(ib); |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 539 | if (ob->flags & BF_SHUTW) { |
| 540 | do_close_and_return: |
| 541 | fd_delete(fd); |
| 542 | ob->cons->state = SI_ST_CLO; |
| 543 | return 0; |
| 544 | } |
| 545 | |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 546 | EV_FD_CLR(fd, DIR_RD); |
| 547 | } |
| 548 | |
| 549 | /* Write timeout */ |
| 550 | if (unlikely(!(ob->flags & (BF_SHUTW|BF_WRITE_TIMEOUT)) && tick_is_expired(ob->wex, now_ms))) { |
| 551 | //trace_term(t, TT_HTTP_SRV_13); |
| 552 | ob->flags |= BF_WRITE_TIMEOUT; |
| 553 | if (!ob->cons->err_type) { |
| 554 | //ob->cons->err_loc = t->srv; |
| 555 | ob->cons->err_type = SI_ET_DATA_TO; |
| 556 | } |
| 557 | buffer_shutw(ob); |
| 558 | if (ib->flags & BF_SHUTR) |
| 559 | goto do_close_and_return; |
| 560 | |
| 561 | EV_FD_CLR(fd, DIR_WR); |
| 562 | shutdown(fd, SHUT_WR); |
| 563 | } |
| 564 | return 0; |
| 565 | } |
| 566 | |
| 567 | /* |
| 568 | * Manages a stream_sock connection during its data phase. The buffers are |
| 569 | * examined for various cases of shutdown, then file descriptor and buffers' |
| 570 | * flags are updated accordingly. |
| 571 | */ |
| 572 | int stream_sock_data_update(int fd) |
| 573 | { |
| 574 | struct buffer *ib = fdtab[fd].cb[DIR_RD].b; |
| 575 | struct buffer *ob = fdtab[fd].cb[DIR_WR].b; |
| 576 | |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 577 | DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n", |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 578 | now_ms, __FUNCTION__, |
| 579 | fd, fdtab[fd].owner, |
| 580 | ib, ob, |
| 581 | ib->rex, ob->wex, |
| 582 | ib->flags, ob->flags, |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 583 | ib->l, ob->l, ob->cons->state); |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 584 | |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 585 | /* Check if we need to close the read side */ |
| 586 | if (!(ib->flags & BF_SHUTR)) { |
| 587 | /* Last read, forced read-shutdown, or other end closed */ |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 588 | if (ib->flags & (BF_SHUTR_NOW|BF_SHUTW)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 589 | //trace_term(t, TT_HTTP_SRV_10); |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 590 | buffer_shutr(ib); |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 591 | if (ob->flags & BF_SHUTW) { |
| 592 | fd_delete(fd); |
| 593 | ob->cons->state = SI_ST_CLO; |
| 594 | return 0; |
| 595 | } |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 596 | EV_FD_CLR(fd, DIR_RD); |
| 597 | } |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 598 | } |
| 599 | |
| 600 | /* Check if we need to close the write side */ |
| 601 | if (!(ob->flags & BF_SHUTW)) { |
| 602 | /* Forced write-shutdown or other end closed with empty buffer. */ |
| 603 | if ((ob->flags & BF_SHUTW_NOW) || |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 604 | (ob->flags & (BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) == (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) { |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 605 | //trace_term(t, TT_HTTP_SRV_11); |
| 606 | buffer_shutw(ob); |
| 607 | if (ib->flags & BF_SHUTR) { |
| 608 | fd_delete(fd); |
| 609 | ob->cons->state = SI_ST_CLO; |
| 610 | return 0; |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 611 | } |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 612 | EV_FD_CLR(fd, DIR_WR); |
| 613 | shutdown(fd, SHUT_WR); |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 614 | } |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 615 | } |
| 616 | return 0; /* other cases change nothing */ |
| 617 | } |
| 618 | |
| 619 | |
| 620 | /* |
| 621 | * Updates a connected stream_sock file descriptor status and timeouts |
| 622 | * according to the buffers' flags. It should only be called once after the |
| 623 | * buffer flags have settled down, and before they are cleared. It doesn't |
| 624 | * harm to call it as often as desired (it just slightly hurts performance). |
| 625 | */ |
| 626 | int stream_sock_data_finish(int fd) |
| 627 | { |
| 628 | struct buffer *ib = fdtab[fd].cb[DIR_RD].b; |
| 629 | struct buffer *ob = fdtab[fd].cb[DIR_WR].b; |
| 630 | |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 631 | DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n", |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 632 | now_ms, __FUNCTION__, |
| 633 | fd, fdtab[fd].owner, |
| 634 | ib, ob, |
| 635 | ib->rex, ob->wex, |
| 636 | ib->flags, ob->flags, |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 637 | ib->l, ob->l, ob->cons->state); |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 638 | |
| 639 | /* Check if we need to close the read side */ |
| 640 | if (!(ib->flags & BF_SHUTR)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 641 | /* Read not closed, update FD status and timeout for reads */ |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 642 | if (ib->flags & (BF_FULL|BF_HIJACK)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 643 | /* stop reading */ |
| 644 | EV_FD_COND_C(fd, DIR_RD); |
| 645 | ib->rex = TICK_ETERNITY; |
| 646 | } |
| 647 | else { |
| 648 | /* (re)start reading and update timeout. Note: we don't recompute the timeout |
| 649 | * everytime we get here, otherwise it would risk never to expire. We only |
| 650 | * update it if is was not yet set, or if we already got some read status. |
| 651 | */ |
| 652 | EV_FD_COND_S(fd, DIR_RD); |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 653 | if (!tick_isset(ib->rex) || ib->flags & BF_READ_ACTIVITY) |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 654 | ib->rex = tick_add_ifset(now_ms, ib->rto); |
| 655 | } |
| 656 | } |
| 657 | |
| 658 | /* Check if we need to close the write side */ |
| 659 | if (!(ob->flags & BF_SHUTW)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 660 | /* Write not closed, update FD status and timeout for writes */ |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 661 | if ((ob->flags & BF_EMPTY) || |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 662 | (ob->flags & (BF_HIJACK|BF_WRITE_ENA)) == 0) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 663 | /* stop writing */ |
| 664 | EV_FD_COND_C(fd, DIR_WR); |
| 665 | ob->wex = TICK_ETERNITY; |
| 666 | } |
| 667 | else { |
| 668 | /* (re)start writing and update timeout. Note: we don't recompute the timeout |
| 669 | * everytime we get here, otherwise it would risk never to expire. We only |
| 670 | * update it if is was not yet set, or if we already got some write status. |
| 671 | */ |
| 672 | EV_FD_COND_S(fd, DIR_WR); |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 673 | if (!tick_isset(ob->wex) || ob->flags & BF_WRITE_ACTIVITY) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 674 | ob->wex = tick_add_ifset(now_ms, ob->wto); |
Willy Tarreau | 21e1be8 | 2008-08-29 11:30:14 +0200 | [diff] [blame] | 675 | if (tick_isset(ob->wex) && tick_isset(ib->rex)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 676 | /* Note: depending on the protocol, we don't know if we're waiting |
| 677 | * for incoming data or not. So in order to prevent the socket from |
| 678 | * expiring read timeouts during writes, we refresh the read timeout, |
| 679 | * except if it was already infinite. |
| 680 | */ |
| 681 | ib->rex = ob->wex; |
| 682 | } |
| 683 | } |
| 684 | } |
| 685 | } |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 686 | return 0; |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 687 | } |
| 688 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 689 | |
| 690 | /* |
| 691 | * Local variables: |
| 692 | * c-indent-level: 8 |
| 693 | * c-basic-offset: 8 |
| 694 | * End: |
| 695 | */ |