Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
Willy Tarreau | b277d6e | 2012-05-11 16:59:14 +0200 | [diff] [blame] | 2 | * Functions used to send/receive data using SOCK_STREAM sockets. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 3 | * |
Willy Tarreau | b277d6e | 2012-05-11 16:59:14 +0200 | [diff] [blame] | 4 | * Copyright 2000-2012 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 | |
Willy Tarreau | 6b4aad4 | 2009-01-18 21:59:13 +0100 | [diff] [blame] | 13 | #define _GNU_SOURCE |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 14 | #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 Sivachenko | caf5898 | 2009-08-24 15:11:06 +0400 | [diff] [blame] | 23 | #include <netinet/tcp.h> |
| 24 | |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 25 | #include <common/compat.h> |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 26 | #include <common/config.h> |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 27 | #include <common/debug.h> |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 28 | #include <common/standard.h> |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 29 | #include <common/ticks.h> |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 30 | #include <common/time.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 31 | |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 32 | #include <proto/buffers.h> |
Willy Tarreau | 8b11708 | 2012-08-06 15:06:49 +0200 | [diff] [blame] | 33 | #include <proto/connection.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 34 | #include <proto/fd.h> |
Willy Tarreau | eb47268 | 2010-05-28 18:46:57 +0200 | [diff] [blame] | 35 | #include <proto/freq_ctr.h> |
| 36 | #include <proto/log.h> |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 37 | #include <proto/pipe.h> |
Willy Tarreau | fe598a7 | 2010-09-21 21:48:23 +0200 | [diff] [blame] | 38 | #include <proto/protocols.h> |
Willy Tarreau | 75bf2c9 | 2012-08-20 17:01:35 +0200 | [diff] [blame] | 39 | #include <proto/raw_sock.h> |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 40 | #include <proto/stream_interface.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 41 | #include <proto/task.h> |
| 42 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 43 | #include <types/global.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 44 | |
Willy Tarreau | b277d6e | 2012-05-11 16:59:14 +0200 | [diff] [blame] | 45 | |
Willy Tarreau | af978c4 | 2012-08-20 20:21:01 +0200 | [diff] [blame] | 46 | #if 0 && defined(CONFIG_HAP_LINUX_SPLICE) |
Willy Tarreau | 43d8fb2 | 2011-08-22 17:12:02 +0200 | [diff] [blame] | 47 | #include <common/splice.h> |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 48 | |
| 49 | /* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes |
| 50 | * because of timestamps. Use this as a hint for not looping on splice(). |
| 51 | */ |
| 52 | #define SPLICE_FULL_HINT 16*1448 |
| 53 | |
Willy Tarreau | a9de333 | 2009-11-28 07:47:10 +0100 | [diff] [blame] | 54 | /* how many data we attempt to splice at once when the buffer is configured for |
| 55 | * infinite forwarding */ |
| 56 | #define MAX_SPLICE_AT_ONCE (1<<30) |
| 57 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 58 | /* Returns : |
| 59 | * -1 if splice is not possible or not possible anymore and we must switch to |
| 60 | * user-land copy (eg: to_forward reached) |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 61 | * 0 otherwise, including errors and close. |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 62 | * Sets : |
| 63 | * BF_READ_NULL |
| 64 | * BF_READ_PARTIAL |
| 65 | * BF_WRITE_PARTIAL (during copy) |
Willy Tarreau | ba0b63d | 2009-09-20 08:09:44 +0200 | [diff] [blame] | 66 | * BF_OUT_EMPTY (during copy) |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 67 | * SI_FL_ERR |
| 68 | * SI_FL_WAIT_ROOM |
| 69 | * (SI_FL_WAIT_RECV) |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 70 | * |
| 71 | * This function automatically allocates a pipe from the pipe pool. It also |
| 72 | * carefully ensures to clear b->pipe whenever it leaves the pipe empty. |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 73 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 74 | static int sock_raw_splice_in(struct channel *b, struct stream_interface *si) |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 75 | { |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 76 | static int splice_detects_close; |
Willy Tarreau | fb7508a | 2012-05-21 16:47:54 +0200 | [diff] [blame] | 77 | int fd = si_fd(si); |
Willy Tarreau | 31971e5 | 2009-09-20 12:07:52 +0200 | [diff] [blame] | 78 | int ret; |
| 79 | unsigned long max; |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 80 | int retval = 0; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 81 | |
| 82 | if (!b->to_forward) |
| 83 | return -1; |
| 84 | |
| 85 | if (!(b->flags & BF_KERN_SPLICING)) |
| 86 | return -1; |
| 87 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 88 | if (buffer_not_empty(&b->buf)) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 89 | /* We're embarrassed, there are already data pending in |
| 90 | * the buffer and we don't want to have them at two |
| 91 | * locations at a time. Let's indicate we need some |
| 92 | * place and ask the consumer to hurry. |
| 93 | */ |
| 94 | si->flags |= SI_FL_WAIT_ROOM; |
Willy Tarreau | f9dabec | 2012-08-17 17:33:53 +0200 | [diff] [blame] | 95 | conn_data_stop_recv(&si->conn); |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 96 | b->rex = TICK_ETERNITY; |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 97 | si_chk_snd(b->cons); |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 98 | return 0; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 99 | } |
| 100 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 101 | if (unlikely(b->pipe == NULL)) { |
| 102 | if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 103 | b->flags &= ~BF_KERN_SPLICING; |
| 104 | return -1; |
| 105 | } |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 106 | } |
| 107 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 108 | /* At this point, b->pipe is valid */ |
| 109 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 110 | while (1) { |
Willy Tarreau | a9de333 | 2009-11-28 07:47:10 +0100 | [diff] [blame] | 111 | if (b->to_forward == BUF_INFINITE_FORWARD) |
| 112 | max = MAX_SPLICE_AT_ONCE; |
| 113 | else |
| 114 | max = b->to_forward; |
| 115 | |
Willy Tarreau | 31971e5 | 2009-09-20 12:07:52 +0200 | [diff] [blame] | 116 | if (!max) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 117 | /* It looks like the buffer + the pipe already contain |
| 118 | * the maximum amount of data to be transferred. Try to |
| 119 | * send those data immediately on the other side if it |
| 120 | * is currently waiting. |
| 121 | */ |
| 122 | retval = -1; /* end of forwarding */ |
| 123 | break; |
| 124 | } |
| 125 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 126 | ret = splice(fd, NULL, b->pipe->prod, NULL, max, |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 127 | SPLICE_F_MOVE|SPLICE_F_NONBLOCK); |
| 128 | |
| 129 | if (ret <= 0) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 130 | if (ret == 0) { |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 131 | /* connection closed. This is only detected by |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 132 | * recent kernels (>= 2.6.27.13). If we notice |
| 133 | * it works, we store the info for later use. |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 134 | */ |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 135 | splice_detects_close = 1; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 136 | b->flags |= BF_READ_NULL; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 137 | break; |
| 138 | } |
| 139 | |
| 140 | if (errno == EAGAIN) { |
| 141 | /* there are two reasons for EAGAIN : |
| 142 | * - nothing in the socket buffer (standard) |
| 143 | * - pipe is full |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 144 | * - the connection is closed (kernel < 2.6.27.13) |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 145 | * Since we don't know if pipe is full, we'll |
| 146 | * stop if the pipe is not empty. Anyway, we |
| 147 | * will almost always fill/empty the pipe. |
| 148 | */ |
| 149 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 150 | if (b->pipe->data) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 151 | si->flags |= SI_FL_WAIT_ROOM; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 152 | break; |
| 153 | } |
| 154 | |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 155 | /* We don't know if the connection was closed, |
| 156 | * but if we know splice detects close, then we |
| 157 | * know it for sure. |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 158 | * But if we're called upon POLLIN with an empty |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 159 | * pipe and get EAGAIN, it is suspect enough to |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 160 | * try to fall back to the normal recv scheme |
| 161 | * which will be able to deal with the situation. |
| 162 | */ |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 163 | if (splice_detects_close) |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 164 | conn_data_poll_recv(&si->conn); /* we know for sure that it's EAGAIN */ |
Willy Tarreau | 82a0456 | 2011-12-11 22:37:06 +0100 | [diff] [blame] | 165 | else |
| 166 | retval = -1; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 167 | break; |
| 168 | } |
Willy Tarreau | dc340a9 | 2009-06-28 23:10:19 +0200 | [diff] [blame] | 169 | |
Willy Tarreau | a9de333 | 2009-11-28 07:47:10 +0100 | [diff] [blame] | 170 | if (errno == ENOSYS || errno == EINVAL) { |
Willy Tarreau | dc340a9 | 2009-06-28 23:10:19 +0200 | [diff] [blame] | 171 | /* splice not supported on this end, disable it */ |
| 172 | b->flags &= ~BF_KERN_SPLICING; |
| 173 | si->flags &= ~SI_FL_CAP_SPLICE; |
| 174 | put_pipe(b->pipe); |
| 175 | b->pipe = NULL; |
| 176 | return -1; |
| 177 | } |
| 178 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 179 | /* here we have another error */ |
| 180 | si->flags |= SI_FL_ERR; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 181 | break; |
| 182 | } /* ret <= 0 */ |
| 183 | |
Willy Tarreau | 31971e5 | 2009-09-20 12:07:52 +0200 | [diff] [blame] | 184 | if (b->to_forward != BUF_INFINITE_FORWARD) |
| 185 | b->to_forward -= ret; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 186 | b->total += ret; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 187 | b->pipe->data += ret; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 188 | b->flags |= BF_READ_PARTIAL; |
Willy Tarreau | ba0b63d | 2009-09-20 08:09:44 +0200 | [diff] [blame] | 189 | b->flags &= ~BF_OUT_EMPTY; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 190 | |
Willy Tarreau | 6f4a82c | 2009-03-21 20:43:57 +0100 | [diff] [blame] | 191 | if (b->pipe->data >= SPLICE_FULL_HINT || |
| 192 | ret >= global.tune.recv_enough) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 193 | /* We've read enough of it for this time. */ |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 194 | break; |
| 195 | } |
| 196 | } /* while */ |
| 197 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 198 | if (unlikely(!b->pipe->data)) { |
| 199 | put_pipe(b->pipe); |
| 200 | b->pipe = NULL; |
| 201 | } |
| 202 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 203 | return retval; |
| 204 | } |
| 205 | |
Willy Tarreau | 6b4aad4 | 2009-01-18 21:59:13 +0100 | [diff] [blame] | 206 | #endif /* CONFIG_HAP_LINUX_SPLICE */ |
| 207 | |
| 208 | |
Willy Tarreau | 2ba4465 | 2012-08-20 17:30:32 +0200 | [diff] [blame] | 209 | /* Receive up to <count> bytes from connection <conn>'s socket and store them |
| 210 | * into buffer <buf>. The caller must ensure that <count> is always smaller |
| 211 | * than the buffer's size. Only one call to recv() is performed, unless the |
| 212 | * buffer wraps, in which case a second call may be performed. The connection's |
| 213 | * flags are updated with whatever special event is detected (error, read0, |
| 214 | * empty). The caller is responsible for taking care of those events and |
| 215 | * avoiding the call if inappropriate. The function does not call the |
| 216 | * connection's polling update function, so the caller is responsible for this. |
| 217 | */ |
| 218 | static int raw_sock_to_buf(struct connection *conn, struct buffer *buf, int count) |
| 219 | { |
| 220 | int ret, done = 0; |
| 221 | int try = count; |
| 222 | |
| 223 | /* stop here if we reached the end of data */ |
| 224 | if ((fdtab[conn->t.sock.fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP) |
| 225 | goto read0; |
| 226 | |
| 227 | /* compute the maximum block size we can read at once. */ |
| 228 | if (buffer_empty(buf)) { |
| 229 | /* let's realign the buffer to optimize I/O */ |
| 230 | buf->p = buf->data; |
| 231 | } |
| 232 | else if (buf->data + buf->o < buf->p && |
| 233 | buf->p + buf->i < buf->data + buf->size) { |
| 234 | /* remaining space wraps at the end, with a moving limit */ |
| 235 | if (try > buf->data + buf->size - (buf->p + buf->i)) |
| 236 | try = buf->data + buf->size - (buf->p + buf->i); |
| 237 | } |
| 238 | |
| 239 | /* read the largest possible block. For this, we perform only one call |
| 240 | * to recv() unless the buffer wraps and we exactly fill the first hunk, |
| 241 | * in which case we accept to do it once again. A new attempt is made on |
| 242 | * EINTR too. |
| 243 | */ |
| 244 | while (try) { |
| 245 | ret = recv(conn->t.sock.fd, bi_end(buf), try, 0); |
| 246 | |
| 247 | if (ret > 0) { |
| 248 | buf->i += ret; |
| 249 | done += ret; |
| 250 | if (ret < try) { |
| 251 | /* unfortunately, on level-triggered events, POLL_HUP |
| 252 | * is generally delivered AFTER the system buffer is |
| 253 | * empty, so this one might never match. |
| 254 | */ |
| 255 | if (fdtab[conn->t.sock.fd].ev & FD_POLL_HUP) |
| 256 | goto read0; |
| 257 | break; |
| 258 | } |
| 259 | count -= ret; |
| 260 | try = count; |
| 261 | } |
| 262 | else if (ret == 0) { |
| 263 | goto read0; |
| 264 | } |
| 265 | else if (errno == EAGAIN) { |
| 266 | conn->flags |= CO_FL_WAIT_DATA; |
| 267 | break; |
| 268 | } |
| 269 | else if (errno != EINTR) { |
| 270 | conn->flags |= CO_FL_ERROR; |
| 271 | break; |
| 272 | } |
| 273 | } |
| 274 | return done; |
| 275 | |
| 276 | read0: |
| 277 | conn_sock_read0(conn); |
| 278 | return done; |
| 279 | } |
| 280 | |
| 281 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 282 | /* |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 283 | * This function is called to send buffer data to a stream socket. |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 284 | * It returns -1 in case of unrecoverable error, otherwise zero. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 285 | */ |
Willy Tarreau | fae4499 | 2012-08-20 14:02:10 +0200 | [diff] [blame] | 286 | static int sock_raw_write_loop(struct connection *conn) |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 287 | { |
Willy Tarreau | fae4499 | 2012-08-20 14:02:10 +0200 | [diff] [blame] | 288 | struct stream_interface *si = container_of(conn, struct stream_interface, conn); |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 289 | struct channel *b = si->ob; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 290 | int write_poll = MAX_WRITE_POLL_LOOPS; |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 291 | int ret, max; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 292 | |
Willy Tarreau | af978c4 | 2012-08-20 20:21:01 +0200 | [diff] [blame] | 293 | #if 0 && defined(CONFIG_HAP_LINUX_SPLICE) |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 294 | while (b->pipe) { |
Willy Tarreau | fb7508a | 2012-05-21 16:47:54 +0200 | [diff] [blame] | 295 | ret = splice(b->pipe->cons, NULL, si_fd(si), NULL, b->pipe->data, |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 296 | SPLICE_F_MOVE|SPLICE_F_NONBLOCK); |
| 297 | if (ret <= 0) { |
| 298 | if (ret == 0 || errno == EAGAIN) { |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 299 | conn_data_poll_send(&si->conn); |
| 300 | return 0; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 301 | } |
| 302 | /* here we have another error */ |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 303 | return -1; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | b->flags |= BF_WRITE_PARTIAL; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 307 | b->pipe->data -= ret; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 308 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 309 | if (!b->pipe->data) { |
| 310 | put_pipe(b->pipe); |
| 311 | b->pipe = NULL; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 312 | break; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 313 | } |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 314 | |
| 315 | if (--write_poll <= 0) |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 316 | return 0; |
Willy Tarreau | eb9fd51 | 2011-12-11 22:11:47 +0100 | [diff] [blame] | 317 | |
| 318 | /* The only reason we did not empty the pipe is that the output |
| 319 | * buffer is full. |
| 320 | */ |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 321 | conn_data_poll_send(&si->conn); |
Willy Tarreau | eb9fd51 | 2011-12-11 22:11:47 +0100 | [diff] [blame] | 322 | return 0; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 323 | } |
| 324 | |
| 325 | /* At this point, the pipe is empty, but we may still have data pending |
| 326 | * in the normal buffer. |
| 327 | */ |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 328 | #endif |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 329 | if (!b->buf.o) { |
Willy Tarreau | ba0b63d | 2009-09-20 08:09:44 +0200 | [diff] [blame] | 330 | b->flags |= BF_OUT_EMPTY; |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 331 | return 0; |
Willy Tarreau | ba0b63d | 2009-09-20 08:09:44 +0200 | [diff] [blame] | 332 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 333 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 334 | /* when we're in this loop, we already know that there is no spliced |
| 335 | * data left, and that there are sendable buffered data. |
| 336 | */ |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 337 | while (1) { |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 338 | max = b->buf.o; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 339 | |
Willy Tarreau | 89fa706 | 2012-03-02 16:13:16 +0100 | [diff] [blame] | 340 | /* outgoing data may wrap at the end */ |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 341 | if (b->buf.data + max > b->buf.p) |
| 342 | max = b->buf.data + max - b->buf.p; |
Willy Tarreau | f890dc9 | 2008-12-13 21:12:26 +0100 | [diff] [blame] | 343 | |
Willy Tarreau | 6db06d3 | 2009-08-19 11:14:11 +0200 | [diff] [blame] | 344 | /* check if we want to inform the kernel that we're interested in |
| 345 | * sending more data after this call. We want this if : |
| 346 | * - we're about to close after this last send and want to merge |
| 347 | * the ongoing FIN with the last segment. |
| 348 | * - we know we can't send everything at once and must get back |
| 349 | * here because of unaligned data |
Willy Tarreau | d38b53b | 2010-01-03 11:18:34 +0100 | [diff] [blame] | 350 | * - there is still a finite amount of data to forward |
Willy Tarreau | 6db06d3 | 2009-08-19 11:14:11 +0200 | [diff] [blame] | 351 | * The test is arranged so that the most common case does only 2 |
| 352 | * tests. |
Willy Tarreau | fb14edc | 2009-06-14 15:24:37 +0200 | [diff] [blame] | 353 | */ |
Willy Tarreau | fb14edc | 2009-06-14 15:24:37 +0200 | [diff] [blame] | 354 | |
Willy Tarreau | face839 | 2010-01-03 11:37:54 +0100 | [diff] [blame] | 355 | if (MSG_NOSIGNAL && MSG_MORE) { |
Willy Tarreau | 6db06d3 | 2009-08-19 11:14:11 +0200 | [diff] [blame] | 356 | unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL; |
| 357 | |
Willy Tarreau | 96e3121 | 2011-05-30 18:10:30 +0200 | [diff] [blame] | 358 | if ((!(b->flags & BF_NEVER_WAIT) && |
| 359 | ((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) || |
| 360 | (b->flags & BF_EXPECT_MORE))) || |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 361 | ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->buf.o)) || |
| 362 | (max != b->buf.o)) { |
Willy Tarreau | face839 | 2010-01-03 11:37:54 +0100 | [diff] [blame] | 363 | send_flag |= MSG_MORE; |
| 364 | } |
Willy Tarreau | 6db06d3 | 2009-08-19 11:14:11 +0200 | [diff] [blame] | 365 | |
Willy Tarreau | 2be3939 | 2010-01-03 17:24:51 +0100 | [diff] [blame] | 366 | /* this flag has precedence over the rest */ |
| 367 | if (b->flags & BF_SEND_DONTWAIT) |
| 368 | send_flag &= ~MSG_MORE; |
| 369 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 370 | ret = send(si_fd(si), bo_ptr(&b->buf), max, send_flag); |
Willy Tarreau | d6d0690 | 2009-08-19 11:22:33 +0200 | [diff] [blame] | 371 | } else { |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 372 | int skerr; |
| 373 | socklen_t lskerr = sizeof(skerr); |
| 374 | |
Willy Tarreau | fb7508a | 2012-05-21 16:47:54 +0200 | [diff] [blame] | 375 | ret = getsockopt(si_fd(si), SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
Willy Tarreau | c642348 | 2006-10-15 14:59:03 +0200 | [diff] [blame] | 376 | if (ret == -1 || skerr) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 377 | ret = -1; |
| 378 | else |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 379 | ret = send(si_fd(si), bo_ptr(&b->buf), max, MSG_DONTWAIT); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 380 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 381 | |
| 382 | if (ret > 0) { |
Willy Tarreau | 505e34a | 2012-07-06 10:17:53 +0200 | [diff] [blame] | 383 | if (si->conn.flags & CO_FL_WAIT_L4_CONN) { |
| 384 | si->conn.flags &= ~CO_FL_WAIT_L4_CONN; |
Willy Tarreau | 8ae52cb | 2012-05-20 10:38:46 +0200 | [diff] [blame] | 385 | si->exp = TICK_ETERNITY; |
| 386 | } |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 387 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 388 | b->flags |= BF_WRITE_PARTIAL; |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 389 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 390 | b->buf.o -= ret; |
| 391 | if (likely(!buffer_len(&b->buf))) |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 392 | /* optimize data alignment in the buffer */ |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 393 | b->buf.p = b->buf.data; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 394 | |
Willy Tarreau | 9dab5fc | 2012-05-07 11:56:55 +0200 | [diff] [blame] | 395 | if (likely(!bi_full(b))) |
Willy Tarreau | 02d6cfc | 2012-03-01 18:19:58 +0100 | [diff] [blame] | 396 | b->flags &= ~BF_FULL; |
| 397 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 398 | if (!b->buf.o) { |
Willy Tarreau | f17810e | 2012-03-09 18:10:44 +0100 | [diff] [blame] | 399 | /* Always clear both flags once everything has been sent, they're one-shot */ |
| 400 | b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT); |
Willy Tarreau | ba0b63d | 2009-09-20 08:09:44 +0200 | [diff] [blame] | 401 | if (likely(!b->pipe)) |
| 402 | b->flags |= BF_OUT_EMPTY; |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 403 | break; |
Willy Tarreau | ba0b63d | 2009-09-20 08:09:44 +0200 | [diff] [blame] | 404 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 405 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 406 | /* if the system buffer is full, don't insist */ |
| 407 | if (ret < max) |
| 408 | break; |
| 409 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 410 | if (--write_poll <= 0) |
| 411 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 412 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 413 | else if (ret == 0 || errno == EAGAIN) { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 414 | /* nothing written, we need to poll for write first */ |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 415 | conn_data_poll_send(&si->conn); |
| 416 | return 0; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 417 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 418 | else { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 419 | /* bad, we got an error */ |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 420 | return -1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 421 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 422 | } /* while (1) */ |
Willy Tarreau | afad0e0 | 2012-08-09 14:45:22 +0200 | [diff] [blame] | 423 | return 0; |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 424 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 425 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 426 | |
Willy Tarreau | 5c979a9 | 2012-05-07 17:15:39 +0200 | [diff] [blame] | 427 | /* stream sock operations */ |
Willy Tarreau | 75bf2c9 | 2012-08-20 17:01:35 +0200 | [diff] [blame] | 428 | struct sock_ops raw_sock = { |
Willy Tarreau | 100c467 | 2012-08-20 12:06:26 +0200 | [diff] [blame] | 429 | .update = stream_int_update_conn, |
Willy Tarreau | 4a36b56 | 2012-08-06 19:31:45 +0200 | [diff] [blame] | 430 | .shutr = NULL, |
| 431 | .shutw = NULL, |
Willy Tarreau | 46a8d92 | 2012-08-20 12:38:36 +0200 | [diff] [blame] | 432 | .chk_rcv = stream_int_chk_rcv_conn, |
Willy Tarreau | de5722c | 2012-08-20 15:01:10 +0200 | [diff] [blame] | 433 | .chk_snd = stream_int_chk_snd_conn, |
Willy Tarreau | ce323de | 2012-08-20 21:41:06 +0200 | [diff] [blame^] | 434 | .read = si_conn_recv_cb, |
Willy Tarreau | eecf6ca | 2012-08-20 15:09:53 +0200 | [diff] [blame] | 435 | .write = si_conn_send_cb, |
Willy Tarreau | fae4499 | 2012-08-20 14:02:10 +0200 | [diff] [blame] | 436 | .snd_buf = sock_raw_write_loop, |
Willy Tarreau | 1fe6bc3 | 2012-08-20 20:27:59 +0200 | [diff] [blame] | 437 | .rcv_buf = raw_sock_to_buf, |
Willy Tarreau | 2420827 | 2012-05-21 17:28:50 +0200 | [diff] [blame] | 438 | .close = NULL, |
Willy Tarreau | 5c979a9 | 2012-05-07 17:15:39 +0200 | [diff] [blame] | 439 | }; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 440 | |
| 441 | /* |
| 442 | * Local variables: |
| 443 | * c-indent-level: 8 |
| 444 | * c-basic-offset: 8 |
| 445 | * End: |
| 446 | */ |