blob: daf3d0701c5196f16803fec5b02cfeea6f230177 [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>
22
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040023#include <netinet/tcp.h>
24
Willy Tarreauc7e42382012-08-24 19:22:53 +020025#include <common/buffer.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020026#include <common/compat.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020027#include <common/config.h>
Willy Tarreaud6f087e2008-01-18 17:20:13 +010028#include <common/debug.h>
Willy Tarreau83749182007-04-15 20:56:27 +020029#include <common/standard.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020030#include <common/ticks.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020031#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020032
Willy Tarreau8b117082012-08-06 15:06:49 +020033#include <proto/connection.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <proto/fd.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020035#include <proto/freq_ctr.h>
36#include <proto/log.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010037#include <proto/pipe.h>
Willy Tarreau75bf2c92012-08-20 17:01:35 +020038#include <proto/raw_sock.h>
Willy Tarreau73b013b2012-05-21 16:31:45 +020039#include <proto/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040#include <proto/task.h>
41
Willy Tarreau5bd8c372009-01-19 00:32:22 +010042#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020043
Willy Tarreaub277d6e2012-05-11 16:59:14 +020044
Willy Tarreau96199b12012-08-24 00:46:52 +020045#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau43d8fb22011-08-22 17:12:02 +020046#include <common/splice.h>
Willy Tarreau5bd8c372009-01-19 00:32:22 +010047
48/* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes
49 * because of timestamps. Use this as a hint for not looping on splice().
50 */
51#define SPLICE_FULL_HINT 16*1448
52
Willy Tarreaua9de3332009-11-28 07:47:10 +010053/* how many data we attempt to splice at once when the buffer is configured for
54 * infinite forwarding */
55#define MAX_SPLICE_AT_ONCE (1<<30)
56
Willy Tarreaub6daedd2013-01-07 16:57:09 +010057/* Versions of splice between 2.6.25 and 2.6.27.12 were bogus and would return EAGAIN
58 * on incoming shutdowns. On these versions, we have to call recv() after such a return
59 * in order to find whether splice is OK or not. Since 2.6.27.13 we don't need to do
60 * this anymore, and we can avoid this logic by defining ASSUME_SPLICE_WORKS.
61 */
62
Willy Tarreau5bd8c372009-01-19 00:32:22 +010063/* Returns :
Willy Tarreau96199b12012-08-24 00:46:52 +020064 * -1 if splice() is not supported
65 * >= 0 to report the amount of spliced bytes.
66 * connection flags are updated (error, read0, wait_room, wait_data).
67 * The caller must have previously allocated the pipe.
Willy Tarreau5bd8c372009-01-19 00:32:22 +010068 */
Willy Tarreau96199b12012-08-24 00:46:52 +020069int raw_sock_to_pipe(struct connection *conn, struct pipe *pipe, unsigned int count)
Willy Tarreau5bd8c372009-01-19 00:32:22 +010070{
Willy Tarreaub6daedd2013-01-07 16:57:09 +010071#ifndef ASSUME_SPLICE_WORKS
Christopher Faulet1bc04c72017-10-29 20:14:08 +010072 static THREAD_LOCAL int splice_detects_close;
Willy Tarreaub6daedd2013-01-07 16:57:09 +010073#endif
Willy Tarreau31971e52009-09-20 12:07:52 +020074 int ret;
Willy Tarreauafad0e02012-08-09 14:45:22 +020075 int retval = 0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +010076
Willy Tarreauf79c8172013-10-21 16:30:56 +020077
Willy Tarreaufd803bb2014-01-20 15:13:07 +010078 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +020079 return 0;
80
Willy Tarreau585744b2017-08-24 14:31:19 +020081 if (!fd_recv_ready(conn->handle.fd))
Willy Tarreaufd803bb2014-01-20 15:13:07 +010082 return 0;
83
Willy Tarreau256b9c52017-10-25 09:30:13 +020084 conn_refresh_polling_flags(conn);
Willy Tarreauce3eda72013-12-05 00:49:40 +010085 errno = 0;
86
Willy Tarreau96199b12012-08-24 00:46:52 +020087 /* Under Linux, if FD_POLL_HUP is set, we have reached the end.
88 * Since older splice() implementations were buggy and returned
89 * EAGAIN on end of read, let's bypass the call to splice() now.
90 */
Willy Tarreau585744b2017-08-24 14:31:19 +020091 if (unlikely(!(fdtab[conn->handle.fd].ev & FD_POLL_IN))) {
Willy Tarreau6f5d1412012-10-04 20:38:49 +020092 /* stop here if we reached the end of data */
Willy Tarreau585744b2017-08-24 14:31:19 +020093 if ((fdtab[conn->handle.fd].ev & (FD_POLL_ERR|FD_POLL_HUP)) == FD_POLL_HUP)
Willy Tarreau6f5d1412012-10-04 20:38:49 +020094 goto out_read0;
95
96 /* report error on POLL_ERR before connection establishment */
Willy Tarreau585744b2017-08-24 14:31:19 +020097 if ((fdtab[conn->handle.fd].ev & FD_POLL_ERR) && (conn->flags & CO_FL_WAIT_L4_CONN)) {
Willy Tarreau26f4a042013-12-04 23:44:10 +010098 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreauce3eda72013-12-05 00:49:40 +010099 errno = 0; /* let the caller do a getsockopt() if it wants it */
Willy Tarreau256b9c52017-10-25 09:30:13 +0200100 goto leave;
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200101 }
102 }
Willy Tarreaua9de3332009-11-28 07:47:10 +0100103
Willy Tarreau96199b12012-08-24 00:46:52 +0200104 while (count) {
105 if (count > MAX_SPLICE_AT_ONCE)
106 count = MAX_SPLICE_AT_ONCE;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100107
Willy Tarreau585744b2017-08-24 14:31:19 +0200108 ret = splice(conn->handle.fd, NULL, pipe->prod, NULL, count,
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100109 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
110
111 if (ret <= 0) {
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100112 if (ret == 0) {
Willy Tarreau98b306b2009-01-25 11:11:32 +0100113 /* connection closed. This is only detected by
Willy Tarreau82a04562011-12-11 22:37:06 +0100114 * recent kernels (>= 2.6.27.13). If we notice
115 * it works, we store the info for later use.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100116 */
Willy Tarreaub6daedd2013-01-07 16:57:09 +0100117#ifndef ASSUME_SPLICE_WORKS
Willy Tarreau82a04562011-12-11 22:37:06 +0100118 splice_detects_close = 1;
Willy Tarreaub6daedd2013-01-07 16:57:09 +0100119#endif
Willy Tarreau96199b12012-08-24 00:46:52 +0200120 goto out_read0;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100121 }
122
123 if (errno == EAGAIN) {
124 /* there are two reasons for EAGAIN :
125 * - nothing in the socket buffer (standard)
126 * - pipe is full
Willy Tarreau98b306b2009-01-25 11:11:32 +0100127 * - the connection is closed (kernel < 2.6.27.13)
Willy Tarreau96199b12012-08-24 00:46:52 +0200128 * The last case is annoying but know if we can detect it
129 * and if we can't then we rely on the call to recv() to
130 * get a valid verdict. The difference between the first
131 * two situations is problematic. Since we don't know if
132 * the pipe is full, we'll stop if the pipe is not empty.
133 * Anyway, we will almost always fill/empty the pipe.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100134 */
Willy Tarreau96199b12012-08-24 00:46:52 +0200135 if (pipe->data) {
136 /* alway stop reading until the pipe is flushed */
137 conn->flags |= CO_FL_WAIT_ROOM;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100138 break;
139 }
140
Willy Tarreau82a04562011-12-11 22:37:06 +0100141 /* We don't know if the connection was closed,
142 * but if we know splice detects close, then we
143 * know it for sure.
Willy Tarreau98b306b2009-01-25 11:11:32 +0100144 * But if we're called upon POLLIN with an empty
Willy Tarreau82a04562011-12-11 22:37:06 +0100145 * pipe and get EAGAIN, it is suspect enough to
Willy Tarreau98b306b2009-01-25 11:11:32 +0100146 * try to fall back to the normal recv scheme
147 * which will be able to deal with the situation.
148 */
Willy Tarreaub6daedd2013-01-07 16:57:09 +0100149#ifndef ASSUME_SPLICE_WORKS
Willy Tarreau82a04562011-12-11 22:37:06 +0100150 if (splice_detects_close)
Willy Tarreaub6daedd2013-01-07 16:57:09 +0100151#endif
Willy Tarreau585744b2017-08-24 14:31:19 +0200152 fd_cant_recv(conn->handle.fd); /* we know for sure that it's EAGAIN */
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100153 break;
154 }
Willy Tarreau45b88932012-11-12 12:00:09 +0100155 else if (errno == ENOSYS || errno == EINVAL || errno == EBADF) {
Willy Tarreau96199b12012-08-24 00:46:52 +0200156 /* splice not supported on this end, disable it.
157 * We can safely return -1 since there is no
158 * chance that any data has been piped yet.
159 */
Willy Tarreau256b9c52017-10-25 09:30:13 +0200160 retval = -1;
161 goto leave;
Willy Tarreaudc340a92009-06-28 23:10:19 +0200162 }
Willy Tarreau96199b12012-08-24 00:46:52 +0200163 else if (errno == EINTR) {
164 /* try again */
165 continue;
166 }
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100167 /* here we have another error */
Willy Tarreau96199b12012-08-24 00:46:52 +0200168 conn->flags |= CO_FL_ERROR;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100169 break;
170 } /* ret <= 0 */
171
Willy Tarreau96199b12012-08-24 00:46:52 +0200172 retval += ret;
173 pipe->data += ret;
Willy Tarreau4fc90ef2013-04-06 11:29:39 +0200174 count -= ret;
Willy Tarreaubaf2a502013-01-07 16:38:26 +0100175
Willy Tarreau96199b12012-08-24 00:46:52 +0200176 if (pipe->data >= SPLICE_FULL_HINT || ret >= global.tune.recv_enough) {
177 /* We've read enough of it for this time, let's stop before
178 * being asked to poll.
179 */
Willy Tarreau61d39a02013-07-18 21:49:32 +0200180 conn->flags |= CO_FL_WAIT_ROOM;
Willy Tarreau585744b2017-08-24 14:31:19 +0200181 fd_done_recv(conn->handle.fd);
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100182 break;
183 }
184 } /* while */
185
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200186 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && retval)
187 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200188
189 leave:
190 conn_cond_update_sock_polling(conn);
Willy Tarreau96199b12012-08-24 00:46:52 +0200191 return retval;
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100192
Willy Tarreau96199b12012-08-24 00:46:52 +0200193 out_read0:
194 conn_sock_read0(conn);
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200195 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200196 goto leave;
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100197}
198
Willy Tarreau96199b12012-08-24 00:46:52 +0200199/* Send as many bytes as possible from the pipe to the connection's socket.
200 */
201int raw_sock_from_pipe(struct connection *conn, struct pipe *pipe)
202{
203 int ret, done;
204
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100205 if (!conn_ctrl_ready(conn))
206 return 0;
207
Willy Tarreau585744b2017-08-24 14:31:19 +0200208 if (!fd_send_ready(conn->handle.fd))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200209 return 0;
210
Willy Tarreau256b9c52017-10-25 09:30:13 +0200211 conn_refresh_polling_flags(conn);
Willy Tarreau96199b12012-08-24 00:46:52 +0200212 done = 0;
213 while (pipe->data) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200214 ret = splice(pipe->cons, NULL, conn->handle.fd, NULL, pipe->data,
Willy Tarreau96199b12012-08-24 00:46:52 +0200215 SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
216
217 if (ret <= 0) {
218 if (ret == 0 || errno == EAGAIN) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200219 fd_cant_send(conn->handle.fd);
Willy Tarreau96199b12012-08-24 00:46:52 +0200220 break;
221 }
222 else if (errno == EINTR)
223 continue;
224
225 /* here we have another error */
226 conn->flags |= CO_FL_ERROR;
227 break;
228 }
229
230 done += ret;
231 pipe->data -= ret;
232 }
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200233 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && done)
234 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200235
236 conn_cond_update_sock_polling(conn);
Willy Tarreau96199b12012-08-24 00:46:52 +0200237 return done;
238}
239
Willy Tarreau6b4aad42009-01-18 21:59:13 +0100240#endif /* CONFIG_HAP_LINUX_SPLICE */
241
242
Willy Tarreau2ba44652012-08-20 17:30:32 +0200243/* Receive up to <count> bytes from connection <conn>'s socket and store them
Willy Tarreauabf08d92014-01-14 11:31:27 +0100244 * into buffer <buf>. Only one call to recv() is performed, unless the
Willy Tarreau2ba44652012-08-20 17:30:32 +0200245 * buffer wraps, in which case a second call may be performed. The connection's
246 * flags are updated with whatever special event is detected (error, read0,
247 * empty). The caller is responsible for taking care of those events and
248 * avoiding the call if inappropriate. The function does not call the
249 * connection's polling update function, so the caller is responsible for this.
Willy Tarreauce3eda72013-12-05 00:49:40 +0100250 * errno is cleared before starting so that the caller knows that if it spots an
251 * error without errno, it's pending and can be retrieved via getsockopt(SO_ERROR).
Willy Tarreau2ba44652012-08-20 17:30:32 +0200252 */
Willy Tarreaubfc4d772018-07-18 11:22:03 +0200253static size_t raw_sock_to_buf(struct connection *conn, struct buffer *buf, size_t count)
Willy Tarreau2ba44652012-08-20 17:30:32 +0200254{
Willy Tarreaubfc4d772018-07-18 11:22:03 +0200255 ssize_t ret;
256 size_t try, done = 0;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200257
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100258 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200259 return 0;
260
Willy Tarreau585744b2017-08-24 14:31:19 +0200261 if (!fd_recv_ready(conn->handle.fd))
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100262 return 0;
263
Willy Tarreau256b9c52017-10-25 09:30:13 +0200264 conn_refresh_polling_flags(conn);
Willy Tarreauce3eda72013-12-05 00:49:40 +0100265 errno = 0;
266
Willy Tarreau585744b2017-08-24 14:31:19 +0200267 if (unlikely(!(fdtab[conn->handle.fd].ev & FD_POLL_IN))) {
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200268 /* stop here if we reached the end of data */
Willy Tarreau585744b2017-08-24 14:31:19 +0200269 if ((fdtab[conn->handle.fd].ev & (FD_POLL_ERR|FD_POLL_HUP)) == FD_POLL_HUP)
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200270 goto read0;
271
272 /* report error on POLL_ERR before connection establishment */
Willy Tarreau585744b2017-08-24 14:31:19 +0200273 if ((fdtab[conn->handle.fd].ev & FD_POLL_ERR) && (conn->flags & CO_FL_WAIT_L4_CONN)) {
Willy Tarreau26f4a042013-12-04 23:44:10 +0100274 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200275 goto leave;
Willy Tarreau6f5d1412012-10-04 20:38:49 +0200276 }
277 }
Willy Tarreau2ba44652012-08-20 17:30:32 +0200278
Willy Tarreauabf08d92014-01-14 11:31:27 +0100279 /* let's realign the buffer to optimize I/O */
280 if (buffer_empty(buf))
Willy Tarreau2ba44652012-08-20 17:30:32 +0200281 buf->p = buf->data;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200282
283 /* read the largest possible block. For this, we perform only one call
284 * to recv() unless the buffer wraps and we exactly fill the first hunk,
285 * in which case we accept to do it once again. A new attempt is made on
286 * EINTR too.
287 */
Willy Tarreauabf08d92014-01-14 11:31:27 +0100288 while (count > 0) {
289 /* first check if we have some room after p+i */
290 try = buf->data + buf->size - (buf->p + buf->i);
291 /* otherwise continue between data and p-o */
292 if (try <= 0) {
293 try = buf->p - (buf->data + buf->o);
294 if (try <= 0)
295 break;
296 }
297 if (try > count)
298 try = count;
299
Willy Tarreau8f9c72d2018-06-07 18:46:28 +0200300 ret = recv(conn->handle.fd, b_tail(buf), try, 0);
Willy Tarreau2ba44652012-08-20 17:30:32 +0200301
302 if (ret > 0) {
303 buf->i += ret;
304 done += ret;
305 if (ret < try) {
306 /* unfortunately, on level-triggered events, POLL_HUP
307 * is generally delivered AFTER the system buffer is
Willy Tarreau68128712017-03-13 12:04:34 +0100308 * empty, unless the poller supports POLL_RDHUP. If
309 * we know this is the case, we don't try to read more
310 * as we know there's no more available. Similarly, if
311 * there's no problem with lingering we don't even try
312 * to read an unlikely close from the client since we'll
313 * close first anyway.
Willy Tarreau2ba44652012-08-20 17:30:32 +0200314 */
Willy Tarreau585744b2017-08-24 14:31:19 +0200315 if (fdtab[conn->handle.fd].ev & FD_POLL_HUP)
Willy Tarreau2ba44652012-08-20 17:30:32 +0200316 goto read0;
Willy Tarreau6c11bd22014-01-24 00:54:27 +0100317
Willy Tarreau585744b2017-08-24 14:31:19 +0200318 if ((!fdtab[conn->handle.fd].linger_risk) ||
Willy Tarreau68128712017-03-13 12:04:34 +0100319 (cur_poller.flags & HAP_POLL_F_RDHUP)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200320 fd_done_recv(conn->handle.fd);
Willy Tarreau68128712017-03-13 12:04:34 +0100321 break;
322 }
Willy Tarreau2ba44652012-08-20 17:30:32 +0200323 }
324 count -= ret;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200325 }
326 else if (ret == 0) {
327 goto read0;
328 }
Joshua M. Clulow07249032014-03-03 13:48:42 -0800329 else if (errno == EAGAIN || errno == ENOTCONN) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200330 fd_cant_recv(conn->handle.fd);
Willy Tarreau2ba44652012-08-20 17:30:32 +0200331 break;
332 }
333 else if (errno != EINTR) {
Willy Tarreau26f4a042013-12-04 23:44:10 +0100334 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200335 break;
336 }
337 }
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200338
339 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && done)
340 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200341
342 leave:
343 conn_cond_update_sock_polling(conn);
Willy Tarreau2ba44652012-08-20 17:30:32 +0200344 return done;
345
346 read0:
347 conn_sock_read0(conn);
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200348 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreaudebdc4b2012-12-07 00:01:33 +0100349
350 /* Now a final check for a possible asynchronous low-level error
351 * report. This can happen when a connection receives a reset
352 * after a shutdown, both POLL_HUP and POLL_ERR are queued, and
353 * we might have come from there by just checking POLL_HUP instead
354 * of recv()'s return value 0, so we have no way to tell there was
355 * an error without checking.
356 */
Willy Tarreau585744b2017-08-24 14:31:19 +0200357 if (unlikely(fdtab[conn->handle.fd].ev & FD_POLL_ERR))
Willy Tarreau26f4a042013-12-04 23:44:10 +0100358 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200359 goto leave;
Willy Tarreau2ba44652012-08-20 17:30:32 +0200360}
361
362
Willy Tarreau787db9a2018-06-14 18:31:46 +0200363/* Send up to <count> pending bytes from buffer <buf> to connection <conn>'s
364 * socket. <flags> may contain some CO_SFL_* flags to hint the system about
365 * other pending data for example, but this flag is ignored at the moment.
Willy Tarreau5368d802012-08-21 18:22:06 +0200366 * Only one call to send() is performed, unless the buffer wraps, in which case
367 * a second call may be performed. The connection's flags are updated with
368 * whatever special event is detected (error, empty). The caller is responsible
369 * for taking care of those events and avoiding the call if inappropriate. The
370 * function does not call the connection's polling update function, so the caller
Willy Tarreau787db9a2018-06-14 18:31:46 +0200371 * is responsible for this. It's up to the caller to update the buffer's contents
372 * based on the return value.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200373 */
Willy Tarreau787db9a2018-06-14 18:31:46 +0200374static size_t raw_sock_from_buf(struct connection *conn, const struct buffer *buf, size_t count, int flags)
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100375{
Willy Tarreau787db9a2018-06-14 18:31:46 +0200376 ssize_t ret;
377 size_t try, done;
378 int send_flag;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200379
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100380 if (!conn_ctrl_ready(conn))
381 return 0;
382
Willy Tarreau585744b2017-08-24 14:31:19 +0200383 if (!fd_send_ready(conn->handle.fd))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200384 return 0;
385
Willy Tarreau256b9c52017-10-25 09:30:13 +0200386 conn_refresh_polling_flags(conn);
Willy Tarreau5368d802012-08-21 18:22:06 +0200387 done = 0;
388 /* send the largest possible block. For this we perform only one call
389 * to send() unless the buffer wraps and we exactly fill the first hunk,
390 * in which case we accept to do it once again.
Willy Tarreau5bd8c372009-01-19 00:32:22 +0100391 */
Willy Tarreau787db9a2018-06-14 18:31:46 +0200392 while (count) {
393 try = b_contig_data(buf, done);
394 if (try > count)
395 try = count;
Willy Tarreauf890dc92008-12-13 21:12:26 +0100396
Willy Tarreau5368d802012-08-21 18:22:06 +0200397 send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
Willy Tarreau787db9a2018-06-14 18:31:46 +0200398 if (try < count || flags & CO_SFL_MSG_MORE)
Willy Tarreau7e4086d2014-02-02 01:44:13 +0100399 send_flag |= MSG_MORE;
Willy Tarreaufb14edc2009-06-14 15:24:37 +0200400
Willy Tarreau787db9a2018-06-14 18:31:46 +0200401 ret = send(conn->handle.fd, b_peek(buf, done), try, send_flag);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200402
403 if (ret > 0) {
Willy Tarreau787db9a2018-06-14 18:31:46 +0200404 count -= ret;
Willy Tarreau5368d802012-08-21 18:22:06 +0200405 done += ret;
Willy Tarreaub38903c2008-11-23 21:33:29 +0100406
Willy Tarreauab3e1d32007-06-03 14:10:36 +0200407 /* if the system buffer is full, don't insist */
Willy Tarreau5368d802012-08-21 18:22:06 +0200408 if (ret < try)
Willy Tarreau6996e152007-04-30 14:37:43 +0200409 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200410 }
Willy Tarreau0ea0cf62012-11-11 20:38:30 +0100411 else if (ret == 0 || errno == EAGAIN || errno == ENOTCONN) {
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100412 /* nothing written, we need to poll for write first */
Willy Tarreau585744b2017-08-24 14:31:19 +0200413 fd_cant_send(conn->handle.fd);
Willy Tarreau5368d802012-08-21 18:22:06 +0200414 break;
Willy Tarreau83749182007-04-15 20:56:27 +0200415 }
Willy Tarreau5368d802012-08-21 18:22:06 +0200416 else if (errno != EINTR) {
Willy Tarreau26f4a042013-12-04 23:44:10 +0100417 conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau5368d802012-08-21 18:22:06 +0200418 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200419 }
Willy Tarreau5368d802012-08-21 18:22:06 +0200420 }
Willy Tarreau665e6ee2012-10-04 20:20:46 +0200421 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) && done)
422 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau256b9c52017-10-25 09:30:13 +0200423
424 conn_cond_update_sock_polling(conn);
Willy Tarreau5368d802012-08-21 18:22:06 +0200425 return done;
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100426}
Willy Tarreau6996e152007-04-30 14:37:43 +0200427
Willy Tarreau0c2fc1f2009-01-18 15:30:37 +0100428
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200429/* transport-layer operations for RAW sockets */
Willy Tarreaud9f5cca2016-12-22 21:08:52 +0100430static struct xprt_ops raw_sock = {
Willy Tarreauc5788912012-08-24 18:12:41 +0200431 .snd_buf = raw_sock_from_buf,
432 .rcv_buf = raw_sock_to_buf,
Willy Tarreau96199b12012-08-24 00:46:52 +0200433#if defined(CONFIG_HAP_LINUX_SPLICE)
434 .rcv_pipe = raw_sock_to_pipe,
435 .snd_pipe = raw_sock_from_pipe,
436#endif
Willy Tarreauc5788912012-08-24 18:12:41 +0200437 .shutr = NULL,
438 .shutw = NULL,
439 .close = NULL,
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100440 .name = "RAW",
Willy Tarreau5c979a92012-05-07 17:15:39 +0200441};
Willy Tarreaubaaee002006-06-26 02:48:02 +0200442
Willy Tarreau13e14102016-12-22 20:25:26 +0100443
444__attribute__((constructor))
Olivier Houchard0d005932017-08-14 15:59:44 +0200445static void __raw_sock_init(void)
Willy Tarreau13e14102016-12-22 20:25:26 +0100446{
447 xprt_register(XPRT_RAW, &raw_sock);
448}
449
Willy Tarreaubaaee002006-06-26 02:48:02 +0200450/*
451 * Local variables:
452 * c-indent-level: 8
453 * c-basic-offset: 8
454 * End:
455 */