blob: a078f2d11a1d78c4ab046d88b73345acfd2eb44a [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02002 * RAW transport layer over SOCK_STREAM sockets.
Willy Tarreaubaaee002006-06-26 02:48:02 +02003 *
Willy Tarreaub277d6e2012-05-11 16:59:14 +02004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau6b4aad42009-01-18 21:59:13 +010013#define _GNU_SOURCE
Willy Tarreaubaaee002006-06-26 02:48:02 +020014#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>
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040022#include <netinet/tcp.h>
23
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020024#include <haproxy/api.h>
Willy Tarreau2741c8c2020-06-02 11:28:02 +020025#include <haproxy/buf.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020026#include <haproxy/connection.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020027#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020028#include <haproxy/fd.h>
29#include <haproxy/freq_ctr.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020030#include <haproxy/global.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/pipe.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020032#include <haproxy/stream_interface.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020033#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020034#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020035#include <haproxy/tools.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036
Willy Tarreaub277d6e2012-05-11 16:59:14 +020037
Willy Tarreaue5733232019-05-22 19:24:06 +020038#if defined(USE_LINUX_SPLICE)
Willy Tarreau5bd8c372009-01-19 00:32:22 +010039
40/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
41 * because of timestamps. Use this as a hint for not looping on splice().
42 */
43#define SPLICE_FULL_HINT 16*1448
44
Willy Tarreaua9de3332009-11-28 07:47:10 +010045/* how many data we attempt to splice at once when the buffer is configured for
46 * infinite forwarding */
47#define MAX_SPLICE_AT_ONCE (1<<30)
48
Willy Tarreau5bd8c372009-01-19 00:32:22 +010049/* Returns :
Willy Tarreau96199b12012-08-24 00:46:52 +020050 * -1 if splice() is not supported
51 * >= 0 to report the amount of spliced bytes.
52 * connection flags are updated (error, read0, wait_room, wait_data).
53 * The caller must have previously allocated the pipe.
Willy Tarreau5bd8c372009-01-19 00:32:22 +010054 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +010055int raw_sock_to_pipe(struct connection *conn, void *xprt_ctx, struct pipe *pipe, unsigned int count)
Willy Tarreau5bd8c372009-01-19 00:32:22 +010056{
Willy Tarreau31971e52009-09-20 12:07:52 +020057 int ret;
Willy Tarreauafad0e02012-08-09 14:45:22 +020058 int retval = 0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010059
Willy Tarreauf79c8172013-10-21 16:30:56 +020060
Willy Tarreaufd803bb2014-01-20 15:13:07 +010061 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +020062 return 0;
63
Willy Tarreau585744b2017-08-24 14:31:19 +020064 if (!fd_recv_ready(conn->handle.fd))
Willy Tarreaufd803bb2014-01-20 15:13:07 +010065 return 0;
66
Willy Tarreaue2a0eec2020-01-17 09:59:40 +010067 conn->flags &= ~CO_FL_WAIT_ROOM;
Willy Tarreauce3eda72013-12-05 00:49:40 +010068 errno = 0;
69
Willy Tarreau96199b12012-08-24 00:46:52 +020070 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
71 * Since older splice() implementations were buggy and returned
72 * EAGAIN on end of read, let's bypass the call to splice() now.
73 */
Willy Tarreauf5090652021-04-06 17:23:40 +020074 if (unlikely(!(fdtab[conn->handle.fd].state & FD_POLL_IN))) {
Willy Tarreau6f5d1412012-10-04 20:38:49 +020075 /* stop here if we reached the end of data */
Willy Tarreauf5090652021-04-06 17:23:40 +020076 if ((fdtab[conn->handle.fd].state & (FD_POLL_ERR|FD_POLL_HUP)) == FD_POLL_HUP)
Willy Tarreau6f5d1412012-10-04 20:38:49 +020077 goto out_read0;
78
79 /* report error on POLL_ERR before connection establishment */
Willy Tarreauf5090652021-04-06 17:23:40 +020080 if ((fdtab[conn->handle.fd].state & FD_POLL_ERR) && (conn->flags & CO_FL_WAIT_L4_CONN)) {
Willy Tarreau26f4a042013-12-04 23:44:10 +010081 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreauce3eda72013-12-05 00:49:40 +010082 errno = 0; /* let the caller do a getsockopt() if it wants it */
Willy Tarreau256b9c52017-10-25 09:30:13 +020083 goto leave;
Willy Tarreau6f5d1412012-10-04 20:38:49 +020084 }
85 }
Willy Tarreaua9de3332009-11-28 07:47:10 +010086
Willy Tarreau96199b12012-08-24 00:46:52 +020087 while (count) {
88 if (count > MAX_SPLICE_AT_ONCE)
89 count = MAX_SPLICE_AT_ONCE;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010090
Willy Tarreau585744b2017-08-24 14:31:19 +020091 ret = splice(conn->handle.fd, NULL, pipe->prod, NULL, count,
Willy Tarreau5bd8c372009-01-19 00:32:22 +010092 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
93
94 if (ret <= 0) {
Willy Tarreau38447472019-05-22 19:55:24 +020095 if (ret == 0)
Willy Tarreau96199b12012-08-24 00:46:52 +020096 goto out_read0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010097
98 if (errno == EAGAIN) {
99 /* there are two reasons for EAGAIN :
100 * - nothing in the socket buffer (standard)
101 * - pipe is full
Willy Tarreau38447472019-05-22 19:55:24 +0200102 * The difference between these two situations
103 * is problematic. Since we don't know if the
104 * pipe is full, we'll stop if the pipe is not
105 * empty. Anyway, we will almost always fill or
106 * empty the pipe.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100107 */
Willy Tarreau96199b12012-08-24 00:46:52 +0200108 if (pipe->data) {
Ilya Shipitsince7b00f2020-03-23 22:28:40 +0500109 /* always stop reading until the pipe is flushed */
Willy Tarreau96199b12012-08-24 00:46:52 +0200110 conn->flags |= CO_FL_WAIT_ROOM;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100111 break;
112 }
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100113 /* socket buffer exhausted */
114 fd_cant_recv(conn->handle.fd);
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100115 break;
116 }
Willy Tarreau45b88932012-11-12 12:00:09 +0100117 else if (errno == ENOSYS || errno == EINVAL || errno == EBADF) {
Willy Tarreau96199b12012-08-24 00:46:52 +0200118 /* splice not supported on this end, disable it.
119 * We can safely return -1 since there is no
120 * chance that any data has been piped yet.
121 */
Willy Tarreau256b9c52017-10-25 09:30:13 +0200122 retval = -1;
123 goto leave;
Willy Tarreaudc340a92009-06-28 23:10:19 +0200124 }
Willy Tarreau96199b12012-08-24 00:46:52 +0200125 else if (errno == EINTR) {
126 /* try again */
127 continue;
128 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100129 /* here we have another error */
Willy Tarreau96199b12012-08-24 00:46:52 +0200130 conn->flags |= CO_FL_ERROR;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100131 break;
132 } /* ret <= 0 */
133
Willy Tarreau96199b12012-08-24 00:46:52 +0200134 retval += ret;
135 pipe->data += ret;
Willy Tarreau4fc90ef2013-04-06 11:29:39 +0200136 count -= ret;
Willy Tarreaubaf2a502013-01-07 16:38:26 +0100137
Willy Tarreau96199b12012-08-24 00:46:52 +0200138 if (pipe->data >= SPLICE_FULL_HINT || ret >= global.tune.recv_enough) {
139 /* We've read enough of it for this time, let's stop before
140 * being asked to poll.
141 */
Willy Tarreau61d39a02013-07-18 21:49:32 +0200142 conn->flags |= CO_FL_WAIT_ROOM;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100143 break;
144 }
145 } /* while */
146
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200147 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && retval)
148 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200149
150 leave:
Willy Tarreau7cf0e452019-05-23 11:39:14 +0200151 if (retval > 0) {
152 /* we count the total bytes sent, and the send rate for 32-byte
153 * blocks. The reason for the latter is that freq_ctr are
154 * limited to 4GB and that it's not enough per second.
155 */
156 _HA_ATOMIC_ADD(&global.out_bytes, retval);
Christopher Fauletaaa70852020-07-10 13:56:30 +0200157 _HA_ATOMIC_ADD(&global.spliced_out_bytes, retval);
Willy Tarreau7cf0e452019-05-23 11:39:14 +0200158 update_freq_ctr(&global.out_32bps, (retval + 16) / 32);
159 }
Willy Tarreau96199b12012-08-24 00:46:52 +0200160 return retval;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100161
Willy Tarreau96199b12012-08-24 00:46:52 +0200162 out_read0:
163 conn_sock_read0(conn);
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200164 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200165 goto leave;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100166}
167
Willy Tarreau96199b12012-08-24 00:46:52 +0200168/* Send as many bytes as possible from the pipe to the connection's socket.
169 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100170int raw_sock_from_pipe(struct connection *conn, void *xprt_ctx, struct pipe *pipe)
Willy Tarreau96199b12012-08-24 00:46:52 +0200171{
172 int ret, done;
173
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100174 if (!conn_ctrl_ready(conn))
175 return 0;
176
Willy Tarreau585744b2017-08-24 14:31:19 +0200177 if (!fd_send_ready(conn->handle.fd))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200178 return 0;
179
Willy Tarreaua8c7e8e2020-01-23 18:17:55 +0100180 if (conn->flags & CO_FL_SOCK_WR_SH) {
181 /* it's already closed */
182 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH;
183 errno = EPIPE;
184 return 0;
185 }
186
Willy Tarreau96199b12012-08-24 00:46:52 +0200187 done = 0;
188 while (pipe->data) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200189 ret = splice(pipe->cons, NULL, conn->handle.fd, NULL, pipe->data,
Willy Tarreau96199b12012-08-24 00:46:52 +0200190 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
191
192 if (ret <= 0) {
193 if (ret == 0 || errno == EAGAIN) {
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100194 fd_cant_send(conn->handle.fd);
Willy Tarreau96199b12012-08-24 00:46:52 +0200195 break;
196 }
197 else if (errno == EINTR)
198 continue;
199
200 /* here we have another error */
201 conn->flags |= CO_FL_ERROR;
202 break;
203 }
204
205 done += ret;
206 pipe->data -= ret;
207 }
Willy Tarreauccf3f6d2019-09-05 17:05:05 +0200208 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && done) {
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200209 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreauccf3f6d2019-09-05 17:05:05 +0200210 }
Willy Tarreau256b9c52017-10-25 09:30:13 +0200211
Willy Tarreau96199b12012-08-24 00:46:52 +0200212 return done;
213}
214
Willy Tarreaue5733232019-05-22 19:24:06 +0200215#endif /* USE_LINUX_SPLICE */
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100216
217
Willy Tarreau2ba44652012-08-20 17:30:32 +0200218/* Receive up to <count> bytes from connection <conn>'s socket and store them
Willy Tarreauabf08d92014-01-14 11:31:27 +0100219 * into buffer <buf>. Only one call to recv() is performed, unless the
Willy Tarreau2ba44652012-08-20 17:30:32 +0200220 * buffer wraps, in which case a second call may be performed. The connection's
221 * flags are updated with whatever special event is detected (error, read0,
222 * empty). The caller is responsible for taking care of those events and
223 * avoiding the call if inappropriate. The function does not call the
224 * connection's polling update function, so the caller is responsible for this.
Willy Tarreauce3eda72013-12-05 00:49:40 +0100225 * errno is cleared before starting so that the caller knows that if it spots an
226 * error without errno, it's pending and can be retrieved via getsockopt(SO_ERROR).
Willy Tarreau2ba44652012-08-20 17:30:32 +0200227 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100228static size_t raw_sock_to_buf(struct connection *conn, void *xprt_ctx, struct buffer *buf, size_t count, int flags)
Willy Tarreau2ba44652012-08-20 17:30:32 +0200229{
Willy Tarreaubfc4d772018-07-18 11:22:03 +0200230 ssize_t ret;
231 size_t try, done = 0;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200232
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100233 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200234 return 0;
235
Willy Tarreau585744b2017-08-24 14:31:19 +0200236 if (!fd_recv_ready(conn->handle.fd))
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100237 return 0;
238
Willy Tarreaue2a0eec2020-01-17 09:59:40 +0100239 conn->flags &= ~CO_FL_WAIT_ROOM;
Willy Tarreauce3eda72013-12-05 00:49:40 +0100240 errno = 0;
241
Willy Tarreauf5090652021-04-06 17:23:40 +0200242 if (unlikely(!(fdtab[conn->handle.fd].state & FD_POLL_IN))) {
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200243 /* stop here if we reached the end of data */
Willy Tarreauf5090652021-04-06 17:23:40 +0200244 if ((fdtab[conn->handle.fd].state & (FD_POLL_ERR|FD_POLL_HUP)) == FD_POLL_HUP)
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200245 goto read0;
246
247 /* report error on POLL_ERR before connection establishment */
Willy Tarreauf5090652021-04-06 17:23:40 +0200248 if ((fdtab[conn->handle.fd].state & FD_POLL_ERR) && (conn->flags & CO_FL_WAIT_L4_CONN)) {
Willy Tarreau26f4a042013-12-04 23:44:10 +0100249 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200250 goto leave;
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200251 }
252 }
Willy Tarreau2ba44652012-08-20 17:30:32 +0200253
Willy Tarreau2ba44652012-08-20 17:30:32 +0200254 /* read the largest possible block. For this, we perform only one call
255 * to recv() unless the buffer wraps and we exactly fill the first hunk,
256 * in which case we accept to do it once again. A new attempt is made on
257 * EINTR too.
258 */
Willy Tarreauabf08d92014-01-14 11:31:27 +0100259 while (count > 0) {
Willy Tarreau591d4452018-06-15 17:21:00 +0200260 try = b_contig_space(buf);
261 if (!try)
262 break;
263
Willy Tarreauabf08d92014-01-14 11:31:27 +0100264 if (try > count)
265 try = count;
266
Willy Tarreau8f9c72d2018-06-07 18:46:28 +0200267 ret = recv(conn->handle.fd, b_tail(buf), try, 0);
Willy Tarreau2ba44652012-08-20 17:30:32 +0200268
269 if (ret > 0) {
Olivier Houchardacd14032018-06-28 18:17:23 +0200270 b_add(buf, ret);
Willy Tarreau2ba44652012-08-20 17:30:32 +0200271 done += ret;
272 if (ret < try) {
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100273 /* socket buffer exhausted */
274 fd_cant_recv(conn->handle.fd);
275
Willy Tarreau2ba44652012-08-20 17:30:32 +0200276 /* unfortunately, on level-triggered events, POLL_HUP
277 * is generally delivered AFTER the system buffer is
Willy Tarreau68128712017-03-13 12:04:34 +0100278 * empty, unless the poller supports POLL_RDHUP. If
279 * we know this is the case, we don't try to read more
280 * as we know there's no more available. Similarly, if
281 * there's no problem with lingering we don't even try
282 * to read an unlikely close from the client since we'll
283 * close first anyway.
Willy Tarreau2ba44652012-08-20 17:30:32 +0200284 */
Willy Tarreauf5090652021-04-06 17:23:40 +0200285 if (fdtab[conn->handle.fd].state & FD_POLL_HUP)
Willy Tarreau2ba44652012-08-20 17:30:32 +0200286 goto read0;
Willy Tarreau6c11bd22014-01-24 00:54:27 +0100287
Willy Tarreaub41a6e92021-04-06 17:49:19 +0200288 if (!(fdtab[conn->handle.fd].state & FD_LINGER_RISK) ||
Willy Tarreau68128712017-03-13 12:04:34 +0100289 (cur_poller.flags & HAP_POLL_F_RDHUP)) {
Willy Tarreau68128712017-03-13 12:04:34 +0100290 break;
291 }
Willy Tarreau2ba44652012-08-20 17:30:32 +0200292 }
293 count -= ret;
Willy Tarreau716bec22020-02-20 11:04:40 +0100294
295 if (flags & CO_RFL_READ_ONCE)
296 break;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200297 }
298 else if (ret == 0) {
299 goto read0;
300 }
Joshua M. Clulow07249032014-03-03 13:48:42 -0800301 else if (errno == EAGAIN || errno == ENOTCONN) {
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100302 /* socket buffer exhausted */
303 fd_cant_recv(conn->handle.fd);
Willy Tarreau2ba44652012-08-20 17:30:32 +0200304 break;
305 }
306 else if (errno != EINTR) {
Willy Tarreau26f4a042013-12-04 23:44:10 +0100307 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200308 break;
309 }
310 }
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200311
312 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && done)
313 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200314
315 leave:
Willy Tarreau2ba44652012-08-20 17:30:32 +0200316 return done;
317
318 read0:
319 conn_sock_read0(conn);
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200320 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreaudebdc4b2012-12-07 00:01:33 +0100321
322 /* Now a final check for a possible asynchronous low-level error
323 * report. This can happen when a connection receives a reset
324 * after a shutdown, both POLL_HUP and POLL_ERR are queued, and
325 * we might have come from there by just checking POLL_HUP instead
326 * of recv()'s return value 0, so we have no way to tell there was
327 * an error without checking.
328 */
Willy Tarreauf5090652021-04-06 17:23:40 +0200329 if (unlikely(fdtab[conn->handle.fd].state & FD_POLL_ERR))
Willy Tarreau26f4a042013-12-04 23:44:10 +0100330 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200331 goto leave;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200332}
333
334
Willy Tarreau787db9a2018-06-14 18:31:46 +0200335/* Send up to <count> pending bytes from buffer <buf> to connection <conn>'s
336 * socket. <flags> may contain some CO_SFL_* flags to hint the system about
337 * other pending data for example, but this flag is ignored at the moment.
Willy Tarreau5368d802012-08-21 18:22:06 +0200338 * Only one call to send() is performed, unless the buffer wraps, in which case
339 * a second call may be performed. The connection's flags are updated with
340 * whatever special event is detected (error, empty). The caller is responsible
341 * for taking care of those events and avoiding the call if inappropriate. The
342 * function does not call the connection's polling update function, so the caller
Willy Tarreau787db9a2018-06-14 18:31:46 +0200343 * is responsible for this. It's up to the caller to update the buffer's contents
344 * based on the return value.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200345 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100346static size_t raw_sock_from_buf(struct connection *conn, void *xprt_ctx, const struct buffer *buf, size_t count, int flags)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100347{
Willy Tarreau787db9a2018-06-14 18:31:46 +0200348 ssize_t ret;
349 size_t try, done;
350 int send_flag;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200351
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100352 if (!conn_ctrl_ready(conn))
353 return 0;
354
Willy Tarreau585744b2017-08-24 14:31:19 +0200355 if (!fd_send_ready(conn->handle.fd))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200356 return 0;
357
Willy Tarreaua8c7e8e2020-01-23 18:17:55 +0100358 if (conn->flags & CO_FL_SOCK_WR_SH) {
359 /* it's already closed */
360 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH;
361 errno = EPIPE;
362 return 0;
363 }
364
Willy Tarreau5368d802012-08-21 18:22:06 +0200365 done = 0;
366 /* send the largest possible block. For this we perform only one call
367 * to send() unless the buffer wraps and we exactly fill the first hunk,
368 * in which case we accept to do it once again.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100369 */
Willy Tarreau787db9a2018-06-14 18:31:46 +0200370 while (count) {
371 try = b_contig_data(buf, done);
372 if (try > count)
373 try = count;
Willy Tarreauf890dc92008-12-13 21:12:26 +0100374
Willy Tarreau5368d802012-08-21 18:22:06 +0200375 send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
Willy Tarreau787db9a2018-06-14 18:31:46 +0200376 if (try < count || flags & CO_SFL_MSG_MORE)
Willy Tarreau7e4086d2014-02-02 01:44:13 +0100377 send_flag |= MSG_MORE;
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200378
Willy Tarreau787db9a2018-06-14 18:31:46 +0200379 ret = send(conn->handle.fd, b_peek(buf, done), try, send_flag);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200380
381 if (ret > 0) {
Willy Tarreau787db9a2018-06-14 18:31:46 +0200382 count -= ret;
Willy Tarreau5368d802012-08-21 18:22:06 +0200383 done += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100384
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200385 /* if the system buffer is full, don't insist */
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100386 if (ret < try) {
387 fd_cant_send(conn->handle.fd);
Willy Tarreau6996e152007-04-30 14:37:43 +0200388 break;
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100389 }
Willy Tarreau3381bf82020-01-17 17:39:35 +0100390 if (!count)
Willy Tarreau3110eb72020-02-21 10:21:46 +0100391 fd_stop_send(conn->handle.fd);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200392 }
Willy Tarreau034c88c2017-01-23 23:36:45 +0100393 else if (ret == 0 || errno == EAGAIN || errno == ENOTCONN || errno == EINPROGRESS) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100394 /* nothing written, we need to poll for write first */
Willy Tarreau8dd348c2020-02-28 14:09:12 +0100395 fd_cant_send(conn->handle.fd);
Willy Tarreau5368d802012-08-21 18:22:06 +0200396 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200397 }
Willy Tarreau5368d802012-08-21 18:22:06 +0200398 else if (errno != EINTR) {
Willy Tarreau26f4a042013-12-04 23:44:10 +0100399 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau5368d802012-08-21 18:22:06 +0200400 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200401 }
Willy Tarreau5368d802012-08-21 18:22:06 +0200402 }
Willy Tarreauccf3f6d2019-09-05 17:05:05 +0200403 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && done) {
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200404 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreauccf3f6d2019-09-05 17:05:05 +0200405 }
Willy Tarreau256b9c52017-10-25 09:30:13 +0200406
Willy Tarreau7cf0e452019-05-23 11:39:14 +0200407 if (done > 0) {
408 /* we count the total bytes sent, and the send rate for 32-byte
409 * blocks. The reason for the latter is that freq_ctr are
410 * limited to 4GB and that it's not enough per second.
411 */
412 _HA_ATOMIC_ADD(&global.out_bytes, done);
413 update_freq_ctr(&global.out_32bps, (done + 16) / 32);
414 }
Willy Tarreau5368d802012-08-21 18:22:06 +0200415 return done;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100416}
Willy Tarreau6996e152007-04-30 14:37:43 +0200417
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100418/* Called from the upper layer, to subscribe <es> to events <event_type>. The
419 * event subscriber <es> is not allowed to change from a previous call as long
420 * as at least one event is still subscribed. The <event_type> must only be a
421 * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0.
422 */
423static int raw_sock_subscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100424{
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100425 return conn_subscribe(conn, xprt_ctx, event_type, es);
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100426}
427
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100428/* Called from the upper layer, to unsubscribe <es> from events <event_type>.
429 * The <es> pointer is not allowed to differ from the one passed to the
430 * subscribe() call. It always returns zero.
431 */
432static int raw_sock_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100433{
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100434 return conn_unsubscribe(conn, xprt_ctx, event_type, es);
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100435}
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100436
Olivier Houchardca1a57f2021-03-14 00:34:49 +0100437static void raw_sock_close(struct connection *conn, void *xprt_ctx)
438{
439 if (conn->subs != NULL) {
440 conn_unsubscribe(conn, NULL, conn->subs->events, conn->subs);
441 }
442}
443
Olivier Houchard5149b592019-05-23 17:47:36 +0200444/* We can't have an underlying XPRT, so just return -1 to signify failure */
445static int raw_sock_remove_xprt(struct connection *conn, void *xprt_ctx, void *toremove_ctx, const struct xprt_ops *newops, void *newctx)
446{
447 /* This is the lowest xprt we can have, so if we get there we didn't
448 * find the xprt we wanted to remove, that's a bug
449 */
450 BUG_ON(1);
451 return -1;
452}
453
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200454/* transport-layer operations for RAW sockets */
Willy Tarreaud9f5cca2016-12-22 21:08:52 +0100455static struct xprt_ops raw_sock = {
Willy Tarreauc5788912012-08-24 18:12:41 +0200456 .snd_buf = raw_sock_from_buf,
457 .rcv_buf = raw_sock_to_buf,
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100458 .subscribe = raw_sock_subscribe,
459 .unsubscribe = raw_sock_unsubscribe,
Olivier Houchard5149b592019-05-23 17:47:36 +0200460 .remove_xprt = raw_sock_remove_xprt,
Willy Tarreaue5733232019-05-22 19:24:06 +0200461#if defined(USE_LINUX_SPLICE)
Willy Tarreau96199b12012-08-24 00:46:52 +0200462 .rcv_pipe = raw_sock_to_pipe,
463 .snd_pipe = raw_sock_from_pipe,
464#endif
Willy Tarreauc5788912012-08-24 18:12:41 +0200465 .shutr = NULL,
466 .shutw = NULL,
Olivier Houchardca1a57f2021-03-14 00:34:49 +0100467 .close = raw_sock_close,
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100468 .name = "RAW",
Willy Tarreau5c979a92012-05-07 17:15:39 +0200469};
Willy Tarreaubaaee002006-06-26 02:48:02 +0200470
Willy Tarreau13e14102016-12-22 20:25:26 +0100471
472__attribute__((constructor))
Olivier Houchard0d005932017-08-14 15:59:44 +0200473static void __raw_sock_init(void)
Willy Tarreau13e14102016-12-22 20:25:26 +0100474{
475 xprt_register(XPRT_RAW, &raw_sock);
476}
477
Willy Tarreaubaaee002006-06-26 02:48:02 +0200478/*
479 * Local variables:
480 * c-indent-level: 8
481 * c-basic-offset: 8
482 * End:
483 */