blob: 0357552baa719dc59ad2af6e5715aa3ae223969f [file] [log] [blame]
William Lallemand2fe7dd02018-09-11 16:51:29 +02001/*
2 * Socket Pair protocol layer (sockpair)
3 *
4 * Copyright HAProxy Technologies - William Lallemand <wlallemand@haproxy.com>
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 <ctype.h>
14#include <errno.h>
15#include <fcntl.h>
16#include <pwd.h>
17#include <grp.h>
18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21#include <syslog.h>
22#include <time.h>
23
24#include <sys/socket.h>
25#include <sys/stat.h>
26#include <sys/types.h>
27#include <sys/un.h>
28
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020029#include <haproxy/api.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020030#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020031#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020032#include <haproxy/fd.h>
33#include <haproxy/freq_ctr.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020034#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020035#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020036#include <haproxy/listener.h>
Willy Tarreau344b8fc2020-10-15 09:43:31 +020037#include <haproxy/log.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020038#include <haproxy/protocol.h>
Willy Tarreau62292b22020-09-02 17:52:23 +020039#include <haproxy/proto_sockpair.h>
Willy Tarreau686fa3d2020-09-25 19:09:53 +020040#include <haproxy/sock.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020041#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020042#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020043#include <haproxy/version.h>
William Lallemand2fe7dd02018-09-11 16:51:29 +020044
William Lallemand2fe7dd02018-09-11 16:51:29 +020045
William Lallemand2fe7dd02018-09-11 16:51:29 +020046static int sockpair_bind_listener(struct listener *listener, char *errmsg, int errlen);
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +020047static void sockpair_enable_listener(struct listener *listener);
48static void sockpair_disable_listener(struct listener *listener);
Olivier Houchardfdcb0072019-05-06 18:32:29 +020049static int sockpair_connect_server(struct connection *conn, int flags);
Willy Tarreau7d053e42020-10-15 09:19:43 +020050static int sockpair_accepting_conn(const struct receiver *rx);
Willy Tarreau344b8fc2020-10-15 09:43:31 +020051struct connection *sockpair_accept_conn(struct listener *l, int *status);
William Lallemand2fe7dd02018-09-11 16:51:29 +020052
Willy Tarreaub0254cb2020-09-04 08:07:11 +020053struct proto_fam proto_fam_sockpair = {
54 .name = "sockpair",
55 .sock_domain = AF_CUST_SOCKPAIR,
56 .sock_family = AF_UNIX,
57 .sock_addrlen = sizeof(struct sockaddr_un),
58 .l3_addrlen = sizeof(((struct sockaddr_un*)0)->sun_path),
59 .addrcmp = NULL,
60 .bind = sockpair_bind_receiver,
61 .get_src = NULL,
62 .get_dst = NULL,
63};
64
William Lallemand2fe7dd02018-09-11 16:51:29 +020065/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaub9b2fd72020-12-08 14:13:11 +010066struct protocol proto_sockpair = {
Willy Tarreaub366c9a2020-12-08 14:54:20 +010067 .name = "sockpair",
68
69 /* connection layer */
70 .ctrl_type = SOCK_STREAM,
71 .listen = sockpair_bind_listener,
72 .enable = sockpair_enable_listener,
73 .disable = sockpair_disable_listener,
74 .add = default_add_listener,
75 .unbind = default_unbind_listener,
76 .accept_conn = sockpair_accept_conn,
Willy Tarreaude471c42020-12-08 15:50:56 +010077 .ctrl_init = sock_conn_ctrl_init,
78 .ctrl_close = sock_conn_ctrl_close,
Willy Tarreaub366c9a2020-12-08 14:54:20 +010079 .connect = sockpair_connect_server,
Willy Tarreau427c8462020-12-11 16:19:12 +010080 .drain = sock_drain,
Willy Tarreau472125b2020-12-11 17:02:50 +010081 .check_events = sock_check_events,
82 .ignore_events = sock_ignore_events,
Willy Tarreaub366c9a2020-12-08 14:54:20 +010083
84 /* binding layer */
85 /* Note: suspend/resume not supported */
86
87 /* address family */
88 .fam = &proto_fam_sockpair,
89
90 /* socket layer */
91 .sock_type = SOCK_STREAM,
92 .sock_prot = 0,
93 .rx_enable = sock_enable,
94 .rx_disable = sock_disable,
95 .rx_unbind = sock_unbind,
96 .rx_listening = sockpair_accepting_conn,
97 .default_iocb = sock_accept_iocb,
98 .receivers = LIST_HEAD_INIT(proto_sockpair.receivers),
99 .nb_receivers = 0,
William Lallemand2fe7dd02018-09-11 16:51:29 +0200100};
101
Willy Tarreau0108d902018-11-25 19:14:37 +0100102INITCALL1(STG_REGISTER, protocol_register, &proto_sockpair);
103
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200104/* Enable receipt of incoming connections for listener <l>. The receiver must
Willy Tarreaua4380b22020-11-04 13:59:04 +0100105 * still be valid.
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200106 */
107static void sockpair_enable_listener(struct listener *l)
108{
Willy Tarreaua4380b22020-11-04 13:59:04 +0100109 fd_want_recv_safe(l->rx.fd);
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200110}
111
112/* Disable receipt of incoming connections for listener <l>. The receiver must
Willy Tarreaua4380b22020-11-04 13:59:04 +0100113 * still be valid.
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200114 */
115static void sockpair_disable_listener(struct listener *l)
116{
Willy Tarreaua4380b22020-11-04 13:59:04 +0100117 fd_stop_recv(l->rx.fd);
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200118}
119
Willy Tarreau233ad282020-10-15 21:45:15 +0200120/* Binds receiver <rx>, and assigns rx->iocb and rx->owner as the callback
121 * and context, respectively, with ->bind_thread as the thread mask. Returns an
122 * error code made of ERR_* bits on failure or ERR_NONE on success. On failure,
123 * an error message may be passed into <errmsg>. Note that the binding address
124 * is only an FD to receive the incoming FDs on. Thus by definition there is no
125 * real "bind" operation, this only completes the receiver. Such FDs are not
Willy Tarreau62292b22020-09-02 17:52:23 +0200126 * inherited upon reload.
127 */
Willy Tarreau233ad282020-10-15 21:45:15 +0200128int sockpair_bind_receiver(struct receiver *rx, char **errmsg)
Willy Tarreau62292b22020-09-02 17:52:23 +0200129{
130 int err;
131
132 /* ensure we never return garbage */
133 if (errmsg)
134 *errmsg = 0;
135
136 err = ERR_NONE;
137
138 if (rx->flags & RX_F_BOUND)
139 return ERR_NONE;
140
141 if (rx->fd == -1) {
142 err |= ERR_FATAL | ERR_ALERT;
143 memprintf(errmsg, "sockpair may be only used with inherited FDs");
144 goto bind_return;
145 }
146
147 if (rx->fd >= global.maxsock) {
148 err |= ERR_FATAL | ERR_ABORT | ERR_ALERT;
149 memprintf(errmsg, "not enough free sockets (raise '-n' parameter)");
150 goto bind_close_return;
151 }
152
153 if (fcntl(rx->fd, F_SETFL, O_NONBLOCK) == -1) {
154 err |= ERR_FATAL | ERR_ALERT;
155 memprintf(errmsg, "cannot make socket non-blocking");
156 goto bind_close_return;
157 }
158
159 rx->flags |= RX_F_BOUND;
160
Willy Tarreau233ad282020-10-15 21:45:15 +0200161 fd_insert(rx->fd, rx->owner, rx->iocb, thread_mask(rx->settings->bind_thread) & all_threads_mask);
Willy Tarreau62292b22020-09-02 17:52:23 +0200162 return err;
163
164 bind_return:
165 if (errmsg && *errmsg)
166 memprintf(errmsg, "%s [fd %d]", *errmsg, rx->fd);
167
168 return err;
169
170 bind_close_return:
171 close(rx->fd);
172 goto bind_return;
173}
174
William Lallemand2fe7dd02018-09-11 16:51:29 +0200175/* This function changes the state from ASSIGNED to LISTEN. The socket is NOT
176 * enabled for polling. The return value is composed from ERR_NONE,
177 * ERR_RETRYABLE and ERR_FATAL. It may return a warning or an error message in
178 * <errmsg> if the message is at most <errlen> bytes long (including '\0').
179 * Note that <errmsg> may be NULL if <errlen> is also zero.
180 */
181static int sockpair_bind_listener(struct listener *listener, char *errmsg, int errlen)
182{
William Lallemand2fe7dd02018-09-11 16:51:29 +0200183 int err;
Willy Tarreau9eda7a62020-09-02 18:02:00 +0200184 char *msg = NULL;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200185
186 err = ERR_NONE;
187
188 /* ensure we never return garbage */
189 if (errlen)
190 *errmsg = 0;
191
192 if (listener->state != LI_ASSIGNED)
193 return ERR_NONE; /* already bound */
194
Willy Tarreauad33acf2020-09-02 18:40:02 +0200195 if (!(listener->rx.flags & RX_F_BOUND)) {
196 msg = "receiving socket not bound";
197 goto err_return;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200198 }
Willy Tarreauad33acf2020-09-02 18:40:02 +0200199
Willy Tarreaua37b2442020-09-24 07:23:45 +0200200 listener_set_state(listener, LI_LISTEN);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200201 return err;
202
203 err_return:
204 if (msg && errlen)
Willy Tarreau9eda7a62020-09-02 18:02:00 +0200205 snprintf(errmsg, errlen, "%s [fd %d]", msg, listener->rx.fd);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200206 return err;
207}
208
209/*
210 * Send FD over a unix socket
211 *
212 * <send_fd> is the FD to send
213 * <fd> is the fd of the unix socket to use for the transfer
214 *
215 * The iobuf variable could be use in the future to enhance the protocol.
216 */
217int send_fd_uxst(int fd, int send_fd)
218{
219 char iobuf[2];
220 struct iovec iov;
221 struct msghdr msghdr;
222
223 char cmsgbuf[CMSG_SPACE(sizeof(int))];
224 char buf[CMSG_SPACE(sizeof(int))];
225 struct cmsghdr *cmsg = (void *)buf;
226
227 int *fdptr;
228
229 iov.iov_base = iobuf;
230 iov.iov_len = sizeof(iobuf);
231
232 memset(&msghdr, 0, sizeof(msghdr));
233 msghdr.msg_iov = &iov;
234 msghdr.msg_iovlen = 1;
235
236 /* Now send the fds */
237 msghdr.msg_control = cmsgbuf;
238 msghdr.msg_controllen = CMSG_SPACE(sizeof(int));
239
240 cmsg = CMSG_FIRSTHDR(&msghdr);
241 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
242 cmsg->cmsg_level = SOL_SOCKET;
243 cmsg->cmsg_type = SCM_RIGHTS;
244
245 fdptr = (int *)CMSG_DATA(cmsg);
246 memcpy(fdptr, &send_fd, sizeof(send_fd));
247
248 if (sendmsg(fd, &msghdr, 0) != sizeof(iobuf)) {
249 ha_warning("Failed to transfer socket\n");
250 return 1;
251 }
252
253 return 0;
254}
255
256/*
257 *
Joseph Herlant8bb32ae2018-11-25 11:43:27 -0800258 * This function works like uxst_connect_server but instead of creating a
William Lallemand2fe7dd02018-09-11 16:51:29 +0200259 * socket and establishing a connection, it creates a pair of connected
260 * sockets, and send one of them through the destination FD. The destination FD
Willy Tarreau3f4fa092019-07-17 16:42:04 +0200261 * is stored in conn->dst->sin_addr.s_addr during configuration parsing.
William Lallemand2fe7dd02018-09-11 16:51:29 +0200262 *
263 * conn->target may point either to a valid server or to a backend, depending
264 * on conn->target. Only OBJ_TYPE_PROXY and OBJ_TYPE_SERVER are supported. The
265 * <data> parameter is a boolean indicating whether there are data waiting for
266 * being sent or not, in order to adjust data write polling and on some
267 * platforms. The <delack> argument is ignored.
268 *
269 * Note that a pending send_proxy message accounts for data.
270 *
271 * It can return one of :
272 * - SF_ERR_NONE if everything's OK
273 * - SF_ERR_SRVTO if there are no more servers
274 * - SF_ERR_SRVCL if the connection was refused by the server
275 * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
276 * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
277 * - SF_ERR_INTERNAL for any other purely internal errors
278 * Additionally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
279 *
280 * The connection's fd is inserted only when SF_ERR_NONE is returned, otherwise
281 * it's invalid and the caller has nothing to do.
282 */
Olivier Houchardfdcb0072019-05-06 18:32:29 +0200283static int sockpair_connect_server(struct connection *conn, int flags)
William Lallemand2fe7dd02018-09-11 16:51:29 +0200284{
285 int sv[2], fd, dst_fd = -1;
286
287 /* the FD is stored in the sockaddr struct */
Willy Tarreau3f4fa092019-07-17 16:42:04 +0200288 dst_fd = ((struct sockaddr_in *)conn->dst)->sin_addr.s_addr;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200289
William Lallemand2fe7dd02018-09-11 16:51:29 +0200290 if (obj_type(conn->target) != OBJ_TYPE_PROXY &&
291 obj_type(conn->target) != OBJ_TYPE_SERVER) {
292 conn->flags |= CO_FL_ERROR;
293 return SF_ERR_INTERNAL;
294 }
295
296 if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) {
297 ha_alert("socketpair(): Cannot create socketpair. Giving up.\n");
298 conn->flags |= CO_FL_ERROR;
299 return SF_ERR_RESOURCE;
300 }
301
302 fd = conn->handle.fd = sv[1];
303
304 if (fd >= global.maxsock) {
305 /* do not log anything there, it's a normal condition when this option
306 * is used to serialize connections to a server !
307 */
308 ha_alert("socket(): not enough free sockets. Raise -n argument. Giving up.\n");
309 close(sv[0]);
310 close(sv[1]);
311 conn->err_code = CO_ER_CONF_FDLIM;
312 conn->flags |= CO_FL_ERROR;
313 return SF_ERR_PRXCOND; /* it is a configuration limit */
314 }
315
316 if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
317 qfprintf(stderr,"Cannot set client socket to non blocking mode.\n");
318 close(sv[0]);
319 close(sv[1]);
320 conn->err_code = CO_ER_SOCK_ERR;
321 conn->flags |= CO_FL_ERROR;
322 return SF_ERR_INTERNAL;
323 }
324
William Lallemandc03eb012018-11-27 12:02:37 +0100325 if (master == 1 && (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)) {
326 ha_alert("Cannot set CLOEXEC on client socket.\n");
327 close(sv[0]);
328 close(sv[1]);
329 conn->err_code = CO_ER_SOCK_ERR;
330 conn->flags |= CO_FL_ERROR;
331 return SF_ERR_INTERNAL;
332 }
333
William Lallemand2fe7dd02018-09-11 16:51:29 +0200334 if (global.tune.server_sndbuf)
335 setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &global.tune.server_sndbuf, sizeof(global.tune.server_sndbuf));
336
337 if (global.tune.server_rcvbuf)
338 setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &global.tune.server_rcvbuf, sizeof(global.tune.server_rcvbuf));
339
340 /* The new socket is sent on the other side, it should be retrieved and
341 * considered as an 'accept' socket on the server side */
342 if (send_fd_uxst(dst_fd, sv[0]) == -1) {
343 close(sv[0]);
344 close(sv[1]);
345 conn->err_code = CO_ER_SOCK_ERR;
346 conn->flags |= CO_FL_ERROR;
347 return SF_ERR_INTERNAL;
348 }
349
350 close(sv[0]); /* we don't need this side anymore */
351
352 conn->flags &= ~CO_FL_WAIT_L4_CONN;
353
354 conn->flags |= CO_FL_ADDR_TO_SET;
355
356 /* Prepare to send a few handshakes related to the on-wire protocol. */
357 if (conn->send_proxy_ofs)
358 conn->flags |= CO_FL_SEND_PROXY;
359
360 conn_ctrl_init(conn); /* registers the FD */
Willy Tarreaub41a6e92021-04-06 17:49:19 +0200361 HA_ATOMIC_AND(&fdtab[fd].state, ~FD_LINGER_RISK); /* no need to disable lingering */
William Lallemand2fe7dd02018-09-11 16:51:29 +0200362
William Lallemand2fe7dd02018-09-11 16:51:29 +0200363 return SF_ERR_NONE; /* connection is OK */
364}
365
366
367/*
Joseph Herlant8bb32ae2018-11-25 11:43:27 -0800368 * Receives a file descriptor transferred from a unix socket.
William Lallemand2fe7dd02018-09-11 16:51:29 +0200369 *
370 * Return -1 or a socket fd;
371 *
Joseph Herlant8bb32ae2018-11-25 11:43:27 -0800372 * The iobuf variable could be used in the future to enhance the protocol.
William Lallemand2fe7dd02018-09-11 16:51:29 +0200373 */
374int recv_fd_uxst(int sock)
375{
376 struct msghdr msghdr;
377 struct iovec iov;
378 char iobuf[2];
379
380 char cmsgbuf[CMSG_SPACE(sizeof(int))];
381 char buf[CMSG_SPACE(sizeof(int))];
382 struct cmsghdr *cmsg = (void *)buf;
383
384
385 int recv_fd = -1;
386 int ret = -1;
387
388 memset(&msghdr, 0, sizeof(msghdr));
389
390 iov.iov_base = iobuf;
391 iov.iov_len = sizeof(iobuf);
392
393 msghdr.msg_iov = &iov;
394 msghdr.msg_iovlen = 1;
395
396 msghdr.msg_control = cmsgbuf;
397 msghdr.msg_controllen = CMSG_SPACE(sizeof(int));
398
399 iov.iov_len = sizeof(iobuf);
400 iov.iov_base = iobuf;
401
402 while (1) {
403 ret = recvmsg(sock, &msghdr, 0);
404 if (ret == -1 && errno == EINTR)
405 continue;
406 else
407 break;
408 }
409
410 if (ret == -1)
411 return ret;
412
413 cmsg = CMSG_FIRSTHDR(&msghdr);
Willy Tarreau7d7ab432018-09-20 11:39:39 +0200414 if (cmsg && cmsg->cmsg_level == SOL_SOCKET &&
William Lallemand2fe7dd02018-09-11 16:51:29 +0200415 cmsg->cmsg_type == SCM_RIGHTS) {
416 size_t totlen = cmsg->cmsg_len -
417 CMSG_LEN(0);
418 memcpy(&recv_fd, CMSG_DATA(cmsg), totlen);
419 }
420 return recv_fd;
421}
422
Willy Tarreaucc8b6532020-10-13 17:27:34 +0200423/* Tests if the receiver supports accepting connections. Returns positive on
424 * success, 0 if not possible, negative if the socket is non-recoverable. In
425 * practice zero is never returned since we don't support suspending sockets.
426 * The real test consists in verifying we have a connected SOCK_STREAM of
427 * family AF_UNIX.
428 */
Willy Tarreau7d053e42020-10-15 09:19:43 +0200429static int sockpair_accepting_conn(const struct receiver *rx)
Willy Tarreaucc8b6532020-10-13 17:27:34 +0200430{
431 struct sockaddr sa;
432 socklen_t len;
433 int val;
434
435 len = sizeof(val);
436 if (getsockopt(rx->fd, SOL_SOCKET, SO_TYPE, &val, &len) == -1)
437 return -1;
438
439 if (val != SOCK_STREAM)
440 return -1;
441
442 len = sizeof(sa);
443 if (getsockname(rx->fd, &sa, &len) != 0)
444 return -1;
445
446 if (sa.sa_family != AF_UNIX)
447 return -1;
448
449 len = sizeof(val);
450 if (getsockopt(rx->fd, SOL_SOCKET, SO_ACCEPTCONN, &val, &len) == -1)
451 return -1;
452
453 /* Note: cannot be a listening socket, must be established */
454 if (val)
455 return -1;
456
457 return 1;
458}
459
Willy Tarreau344b8fc2020-10-15 09:43:31 +0200460/* Accept an incoming connection from listener <l>, and return it, as well as
461 * a CO_AC_* status code into <status> if not null. Null is returned on error.
462 * <l> must be a valid listener with a valid frontend.
463 */
464struct connection *sockpair_accept_conn(struct listener *l, int *status)
465{
466 struct proxy *p = l->bind_conf->frontend;
467 struct connection *conn = NULL;
468 int ret;
469 int cfd;
470
471 if ((cfd = recv_fd_uxst(l->rx.fd)) != -1)
Willy Tarreau5b597412021-03-05 14:31:52 +0100472 DISGUISE(fcntl(cfd, F_SETFL, O_NONBLOCK));
Willy Tarreau344b8fc2020-10-15 09:43:31 +0200473
474 if (likely(cfd != -1)) {
475 /* Perfect, the connection was accepted */
476 conn = conn_new(&l->obj_type);
477 if (!conn)
478 goto fail_conn;
479
480 if (!sockaddr_alloc(&conn->src, NULL, 0))
481 goto fail_addr;
482
483 /* just like with UNIX sockets, only the family is filled */
484 conn->src->ss_family = AF_UNIX;
485 conn->handle.fd = cfd;
486 conn->flags |= CO_FL_ADDR_FROM_SET;
487 ret = CO_AC_DONE;
488 goto done;
489 }
490
491 switch (errno) {
492 case EAGAIN:
493 ret = CO_AC_DONE; /* nothing more to accept */
Willy Tarreauf5090652021-04-06 17:23:40 +0200494 if (fdtab[l->rx.fd].state & (FD_POLL_HUP|FD_POLL_ERR)) {
Willy Tarreau344b8fc2020-10-15 09:43:31 +0200495 /* the listening socket might have been disabled in a shared
496 * process and we're a collateral victim. We'll just pause for
497 * a while in case it comes back. In the mean time, we need to
498 * clear this sticky flag.
499 */
Willy Tarreauf5090652021-04-06 17:23:40 +0200500 _HA_ATOMIC_AND(&fdtab[l->rx.fd].state, ~(FD_POLL_HUP|FD_POLL_ERR));
Willy Tarreau344b8fc2020-10-15 09:43:31 +0200501 ret = CO_AC_PAUSE;
502 }
503 fd_cant_recv(l->rx.fd);
504 break;
505
506 case EINVAL:
507 /* might be trying to accept on a shut fd (eg: soft stop) */
508 ret = CO_AC_PAUSE;
509 break;
510
511 case EINTR:
512 case ECONNABORTED:
513 ret = CO_AC_RETRY;
514 break;
515
516 case ENFILE:
517 if (p)
518 send_log(p, LOG_EMERG,
519 "Proxy %s reached system FD limit (maxsock=%d). Please check system tunables.\n",
520 p->id, global.maxsock);
521 ret = CO_AC_PAUSE;
522 break;
523
524 case EMFILE:
525 if (p)
526 send_log(p, LOG_EMERG,
527 "Proxy %s reached process FD limit (maxsock=%d). Please check 'ulimit-n' and restart.\n",
528 p->id, global.maxsock);
529 ret = CO_AC_PAUSE;
530 break;
531
532 case ENOBUFS:
533 case ENOMEM:
534 if (p)
535 send_log(p, LOG_EMERG,
536 "Proxy %s reached system memory limit (maxsock=%d). Please check system tunables.\n",
537 p->id, global.maxsock);
538 ret = CO_AC_PAUSE;
539 break;
540
541 default:
542 /* unexpected result, let's give up and let other tasks run */
543 ret = CO_AC_YIELD;
544 }
545 done:
546 if (status)
547 *status = ret;
548 return conn;
549
550 fail_addr:
551 conn_free(conn);
552 conn = NULL;
553 fail_conn:
554 ret = CO_AC_PAUSE;
555 goto done;
556}
557
William Lallemand2fe7dd02018-09-11 16:51:29 +0200558/*
559 * Local variables:
560 * c-indent-level: 8
561 * c-basic-offset: 8
562 * End:
563 */