blob: ad63c4d6ffca4272f4e84d9b7c93298533ae2176 [file] [log] [blame]
Willy Tarreaudd815982007-10-16 12:25:14 +02001/*
Willy Tarreaud1d54542012-09-12 22:58:11 +02002 * Listener management functions.
Willy Tarreaudd815982007-10-16 12:25:14 +02003 *
Willy Tarreau0ccb7442013-01-07 22:54:17 +01004 * Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
Willy Tarreaudd815982007-10-16 12:25:14 +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 Tarreau44489252014-01-14 17:52:01 +010013#define _GNU_SOURCE
Willy Tarreau6ae1ba62014-05-07 19:01:58 +020014#include <ctype.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020015#include <errno.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020016#include <stdio.h>
17#include <string.h>
Willy Tarreau95ccdde2014-02-01 09:28:36 +010018#include <unistd.h>
19#include <fcntl.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020020
Willy Tarreau1bc4aab2012-10-08 20:11:03 +020021#include <common/accept4.h>
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +010022#include <common/cfgparse.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020023#include <common/config.h>
Willy Tarreaudabf2e22007-10-28 21:59:24 +010024#include <common/errors.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010025#include <common/initcall.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020026#include <common/mini-clist.h>
27#include <common/standard.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020028#include <common/time.h>
29
30#include <types/global.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020031#include <types/protocol.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020032
Willy Tarreau645513a2010-05-24 20:55:15 +020033#include <proto/acl.h>
Christopher Fauleta717b992018-04-10 14:43:00 +020034#include <proto/connection.h>
Willy Tarreaub648d632007-10-28 22:13:50 +010035#include <proto/fd.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020036#include <proto/freq_ctr.h>
37#include <proto/log.h>
Willy Tarreau7a798e52016-04-14 11:13:20 +020038#include <proto/listener.h>
Willy Tarreau0de59fd2017-09-15 08:10:44 +020039#include <proto/protocol.h>
William Lallemand2fe7dd02018-09-11 16:51:29 +020040#include <proto/proto_sockpair.h>
Willy Tarreau0ccb7442013-01-07 22:54:17 +010041#include <proto/sample.h>
Willy Tarreaufb0afa72015-04-03 14:46:27 +020042#include <proto/stream.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020043#include <proto/task.h>
Willy Tarreaub648d632007-10-28 22:13:50 +010044
Willy Tarreau26982662012-09-12 23:17:10 +020045/* List head of all known bind keywords */
46static struct bind_kw_list bind_keywords = {
47 .list = LIST_HEAD_INIT(bind_keywords.list)
48};
49
Olivier Houchardf73629d2017-04-05 22:33:04 +020050struct xfer_sock_list *xfer_sock_list = NULL;
51
Willy Tarreau1efafce2019-01-27 15:37:19 +010052#if defined(USE_THREAD)
53
54struct accept_queue_ring accept_queue_rings[MAX_THREADS] __attribute__((aligned(64))) = { };
55
56/* dequeue and process a pending connection from the local accept queue (single
57 * consumer). Returns the accepted fd or -1 if none was found. The listener is
58 * placed into *li. The address is copied into *addr for no more than *addr_len
59 * bytes, and the address length is returned into *addr_len.
60 */
61int accept_queue_pop_sc(struct accept_queue_ring *ring, struct listener **li, void *addr, int *addr_len)
62{
63 struct accept_queue_entry *e;
64 unsigned int pos, next;
65 struct listener *ptr;
66 int len;
67 int fd;
68
69 pos = ring->head;
70
71 if (pos == ring->tail)
72 return -1;
73
74 next = pos + 1;
75 if (next >= ACCEPT_QUEUE_SIZE)
76 next = 0;
77
78 e = &ring->entry[pos];
79
80 /* wait for the producer to update the listener's pointer */
81 while (1) {
82 ptr = e->listener;
83 __ha_barrier_load();
84 if (ptr)
85 break;
86 pl_cpu_relax();
87 }
88
89 fd = e->fd;
90 len = e->addr_len;
91 if (len > *addr_len)
92 len = *addr_len;
93
94 if (likely(len > 0))
95 memcpy(addr, &e->addr, len);
96
97 /* release the entry */
98 e->listener = NULL;
99
100 __ha_barrier_store();
101 ring->head = next;
102
103 *addr_len = len;
104 *li = ptr;
105
106 return fd;
107}
108
109
110/* tries to push a new accepted connection <fd> into ring <ring> for listener
111 * <li>, from address <addr> whose length is <addr_len>. Returns non-zero if it
112 * succeeds, or zero if the ring is full. Supports multiple producers.
113 */
114int accept_queue_push_mp(struct accept_queue_ring *ring, int fd,
115 struct listener *li, const void *addr, int addr_len)
116{
117 struct accept_queue_entry *e;
118 unsigned int pos, next;
119
120 pos = ring->tail;
121 do {
122 next = pos + 1;
123 if (next >= ACCEPT_QUEUE_SIZE)
124 next = 0;
125 if (next == ring->head)
126 return 0; // ring full
Olivier Houchard64213e92019-03-08 18:52:57 +0100127 } while (unlikely(!_HA_ATOMIC_CAS(&ring->tail, &pos, next)));
Willy Tarreau1efafce2019-01-27 15:37:19 +0100128
129
130 e = &ring->entry[pos];
131
132 if (addr_len > sizeof(e->addr))
133 addr_len = sizeof(e->addr);
134
135 if (addr_len)
136 memcpy(&e->addr, addr, addr_len);
137
138 e->addr_len = addr_len;
139 e->fd = fd;
140
141 __ha_barrier_store();
142 /* now commit the change */
143
144 e->listener = li;
145 return 1;
146}
147
148/* proceed with accepting new connections */
149static struct task *accept_queue_process(struct task *t, void *context, unsigned short state)
150{
151 struct accept_queue_ring *ring = context;
152 struct listener *li;
153 struct sockaddr_storage addr;
154 int max_accept = global.tune.maxaccept ? global.tune.maxaccept : 64;
155 int addr_len;
156 int ret;
157 int fd;
158
159 while (max_accept--) {
160 addr_len = sizeof(addr);
161 fd = accept_queue_pop_sc(ring, &li, &addr, &addr_len);
162 if (fd < 0)
163 break;
164
Olivier Houchard64213e92019-03-08 18:52:57 +0100165 _HA_ATOMIC_ADD(&li->thr_conn[tid], 1);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100166 ret = li->accept(li, fd, &addr);
167 if (ret <= 0) {
168 /* connection was terminated by the application */
169 continue;
170 }
171
172 /* increase the per-process number of cumulated sessions, this
173 * may only be done once l->accept() has accepted the connection.
174 */
175 if (!(li->options & LI_O_UNLIMITED)) {
176 HA_ATOMIC_UPDATE_MAX(&global.sps_max,
177 update_freq_ctr(&global.sess_per_sec, 1));
178 if (li->bind_conf && li->bind_conf->is_ssl) {
179 HA_ATOMIC_UPDATE_MAX(&global.ssl_max,
180 update_freq_ctr(&global.ssl_per_sec, 1));
181 }
182 }
183 }
184
185 /* ran out of budget ? Let's come here ASAP */
186 if (max_accept < 0)
187 task_wakeup(t, TASK_WOKEN_IO);
188
189 return t;
190}
191
192/* Initializes the accept-queues. Returns 0 on success, otherwise ERR_* flags */
193static int accept_queue_init()
194{
195 struct task *t;
196 int i;
197
198 for (i = 0; i < global.nbthread; i++) {
199 t = task_new(1UL << i);
200 if (!t) {
201 ha_alert("Out of memory while initializing accept queue for thread %d\n", i);
202 return ERR_FATAL|ERR_ABORT;
203 }
204 t->process = accept_queue_process;
205 t->context = &accept_queue_rings[i];
206 accept_queue_rings[i].task = t;
207 }
208 return 0;
209}
210
211REGISTER_CONFIG_POSTPARSER("multi-threaded accept queue", accept_queue_init);
212
213#endif // USE_THREAD
214
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100215/* This function adds the specified listener's file descriptor to the polling
216 * lists if it is in the LI_LISTEN state. The listener enters LI_READY or
Willy Tarreauae302532014-05-07 19:22:24 +0200217 * LI_FULL state depending on its number of connections. In deamon mode, we
218 * also support binding only the relevant processes to their respective
219 * listeners. We don't do that in debug mode however.
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100220 */
Christopher Fauletf5b8adc2017-06-02 10:00:35 +0200221static void enable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100222{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100223 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100224 if (listener->state == LI_LISTEN) {
William Lallemand095ba4c2017-06-01 17:38:50 +0200225 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau6daac192019-02-02 17:39:53 +0100226 !(proc_mask(listener->bind_conf->bind_proc) & pid_bit)) {
Willy Tarreauae302532014-05-07 19:22:24 +0200227 /* we don't want to enable this listener and don't
228 * want any fd event to reach it.
229 */
Olivier Houchard1fc05162017-04-06 01:05:05 +0200230 if (!(global.tune.options & GTUNE_SOCKET_TRANSFER))
Christopher Faulet510c0d62018-03-16 10:04:47 +0100231 do_unbind_listener(listener, 1);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200232 else {
Christopher Faulet510c0d62018-03-16 10:04:47 +0100233 do_unbind_listener(listener, 0);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200234 listener->state = LI_LISTEN;
235 }
Willy Tarreauae302532014-05-07 19:22:24 +0200236 }
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100237 else if (!listener->maxconn || listener->nbconn < listener->maxconn) {
Willy Tarreau49b046d2012-08-09 12:11:58 +0200238 fd_want_recv(listener->fd);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100239 listener->state = LI_READY;
Willy Tarreauae302532014-05-07 19:22:24 +0200240 }
241 else {
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100242 listener->state = LI_FULL;
243 }
244 }
William Lallemande22f11f2018-09-11 10:06:27 +0200245 /* if this listener is supposed to be only in the master, close it in the workers */
246 if ((global.mode & MODE_MWORKER) &&
247 (listener->options & LI_O_MWORKER) &&
248 master == 0) {
249 do_unbind_listener(listener, 1);
250 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100251 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100252}
253
254/* This function removes the specified listener's file descriptor from the
255 * polling lists if it is in the LI_READY or in the LI_FULL state. The listener
256 * enters LI_LISTEN.
257 */
Christopher Fauletf5b8adc2017-06-02 10:00:35 +0200258static void disable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100259{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100260 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100261 if (listener->state < LI_READY)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200262 goto end;
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100263 if (listener->state == LI_READY)
Willy Tarreau49b046d2012-08-09 12:11:58 +0200264 fd_stop_recv(listener->fd);
Willy Tarreau01abd022019-02-28 10:27:18 +0100265 LIST_DEL_LOCKED(&listener->wait_queue);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100266 listener->state = LI_LISTEN;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200267 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100268 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100269}
270
Willy Tarreaube58c382011-07-24 18:28:10 +0200271/* This function tries to temporarily disable a listener, depending on the OS
272 * capabilities. Linux unbinds the listen socket after a SHUT_RD, and ignores
273 * SHUT_WR. Solaris refuses either shutdown(). OpenBSD ignores SHUT_RD but
274 * closes upon SHUT_WR and refuses to rebind. So a common validation path
275 * involves SHUT_WR && listen && SHUT_RD. In case of success, the FD's polling
276 * is disabled. It normally returns non-zero, unless an error is reported.
277 */
278int pause_listener(struct listener *l)
279{
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200280 int ret = 1;
281
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100282 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200283
Olivier Houchard1fc05162017-04-06 01:05:05 +0200284 if (l->state <= LI_ZOMBIE)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200285 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200286
Willy Tarreau092d8652014-07-07 20:22:12 +0200287 if (l->proto->pause) {
288 /* Returns < 0 in case of failure, 0 if the listener
289 * was totally stopped, or > 0 if correctly paused.
290 */
291 int ret = l->proto->pause(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200292
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200293 if (ret < 0) {
294 ret = 0;
295 goto end;
296 }
Willy Tarreau092d8652014-07-07 20:22:12 +0200297 else if (ret == 0)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200298 goto end;
Willy Tarreaub3fb60b2012-10-04 08:56:31 +0200299 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200300
Willy Tarreau01abd022019-02-28 10:27:18 +0100301 LIST_DEL_LOCKED(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200302
Willy Tarreau49b046d2012-08-09 12:11:58 +0200303 fd_stop_recv(l->fd);
Willy Tarreaube58c382011-07-24 18:28:10 +0200304 l->state = LI_PAUSED;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200305 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100306 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200307 return ret;
Willy Tarreaube58c382011-07-24 18:28:10 +0200308}
309
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200310/* This function tries to resume a temporarily disabled listener. Paused, full,
311 * limited and disabled listeners are handled, which means that this function
312 * may replace enable_listener(). The resulting state will either be LI_READY
313 * or LI_FULL. 0 is returned in case of failure to resume (eg: dead socket).
Willy Tarreauae302532014-05-07 19:22:24 +0200314 * Listeners bound to a different process are not woken up unless we're in
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200315 * foreground mode, and are ignored. If the listener was only in the assigned
316 * state, it's totally rebound. This can happen if a pause() has completely
317 * stopped it. If the resume fails, 0 is returned and an error might be
318 * displayed.
Willy Tarreaube58c382011-07-24 18:28:10 +0200319 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100320int resume_listener(struct listener *l)
Willy Tarreaube58c382011-07-24 18:28:10 +0200321{
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200322 int ret = 1;
323
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100324 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200325
William Lallemand095ba4c2017-06-01 17:38:50 +0200326 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau6daac192019-02-02 17:39:53 +0100327 !(proc_mask(l->bind_conf->bind_proc) & pid_bit))
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200328 goto end;
Willy Tarreau3569df32017-03-15 12:47:46 +0100329
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200330 if (l->state == LI_ASSIGNED) {
331 char msg[100];
332 int err;
333
334 err = l->proto->bind(l, msg, sizeof(msg));
335 if (err & ERR_ALERT)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100336 ha_alert("Resuming listener: %s\n", msg);
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200337 else if (err & ERR_WARN)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100338 ha_warning("Resuming listener: %s\n", msg);
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200339
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200340 if (err & (ERR_FATAL | ERR_ABORT)) {
341 ret = 0;
342 goto end;
343 }
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200344 }
345
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200346 if (l->state < LI_PAUSED || l->state == LI_ZOMBIE) {
347 ret = 0;
348 goto end;
349 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200350
Willy Tarreaub3fb60b2012-10-04 08:56:31 +0200351 if (l->proto->sock_prot == IPPROTO_TCP &&
352 l->state == LI_PAUSED &&
Willy Tarreaue2711c72019-02-27 15:39:41 +0100353 listen(l->fd, listener_backlog(l)) != 0) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200354 ret = 0;
355 goto end;
356 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200357
358 if (l->state == LI_READY)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200359 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200360
Willy Tarreau01abd022019-02-28 10:27:18 +0100361 LIST_DEL_LOCKED(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200362
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100363 if (l->maxconn && l->nbconn >= l->maxconn) {
Willy Tarreaube58c382011-07-24 18:28:10 +0200364 l->state = LI_FULL;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200365 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200366 }
367
Willy Tarreau49b046d2012-08-09 12:11:58 +0200368 fd_want_recv(l->fd);
Willy Tarreaube58c382011-07-24 18:28:10 +0200369 l->state = LI_READY;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200370 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100371 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200372 return ret;
373}
374
Willy Tarreau87b09662015-04-03 00:22:06 +0200375/* Marks a ready listener as full so that the stream code tries to re-enable
Willy Tarreau62793712011-07-24 19:23:38 +0200376 * it upon next close() using resume_listener().
377 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200378static void listener_full(struct listener *l)
Willy Tarreau62793712011-07-24 19:23:38 +0200379{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100380 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200381 if (l->state >= LI_READY) {
Willy Tarreau01abd022019-02-28 10:27:18 +0100382 LIST_DEL_LOCKED(&l->wait_queue);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100383 if (l->state != LI_FULL) {
384 fd_stop_recv(l->fd);
385 l->state = LI_FULL;
386 }
Willy Tarreau62793712011-07-24 19:23:38 +0200387 }
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100388 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200389}
390
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200391/* Marks a ready listener as limited so that we only try to re-enable it when
392 * resources are free again. It will be queued into the specified queue.
393 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200394static void limit_listener(struct listener *l, struct list *list)
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200395{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100396 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200397 if (l->state == LI_READY) {
Willy Tarreau01abd022019-02-28 10:27:18 +0100398 LIST_ADDQ_LOCKED(list, &l->wait_queue);
Willy Tarreau49b046d2012-08-09 12:11:58 +0200399 fd_stop_recv(l->fd);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200400 l->state = LI_LIMITED;
401 }
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100402 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200403}
404
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100405/* This function adds all of the protocol's listener's file descriptors to the
406 * polling lists when they are in the LI_LISTEN state. It is intended to be
407 * used as a protocol's generic enable_all() primitive, for use after the
408 * fork(). It puts the listeners into LI_READY or LI_FULL states depending on
409 * their number of connections. It always returns ERR_NONE.
410 */
411int enable_all_listeners(struct protocol *proto)
412{
413 struct listener *listener;
414
415 list_for_each_entry(listener, &proto->listeners, proto_list)
416 enable_listener(listener);
417 return ERR_NONE;
418}
419
420/* This function removes all of the protocol's listener's file descriptors from
421 * the polling lists when they are in the LI_READY or LI_FULL states. It is
422 * intended to be used as a protocol's generic disable_all() primitive. It puts
423 * the listeners into LI_LISTEN, and always returns ERR_NONE.
424 */
425int disable_all_listeners(struct protocol *proto)
426{
427 struct listener *listener;
428
429 list_for_each_entry(listener, &proto->listeners, proto_list)
430 disable_listener(listener);
431 return ERR_NONE;
432}
433
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200434/* Dequeues all of the listeners waiting for a resource in wait queue <queue>. */
435void dequeue_all_listeners(struct list *list)
436{
Willy Tarreau01abd022019-02-28 10:27:18 +0100437 struct listener *listener;
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200438
Willy Tarreau01abd022019-02-28 10:27:18 +0100439 while ((listener = LIST_POP_LOCKED(list, struct listener *, wait_queue))) {
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200440 /* This cannot fail because the listeners are by definition in
Willy Tarreau01abd022019-02-28 10:27:18 +0100441 * the LI_LIMITED state.
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200442 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100443 resume_listener(listener);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200444 }
445}
446
Christopher Faulet510c0d62018-03-16 10:04:47 +0100447/* Must be called with the lock held. Depending on <do_close> value, it does
448 * what unbind_listener or unbind_listener_no_close should do.
449 */
450void do_unbind_listener(struct listener *listener, int do_close)
Willy Tarreaub648d632007-10-28 22:13:50 +0100451{
Olivier Houcharda5188562019-03-08 15:35:42 +0100452 if (listener->state == LI_READY && fd_updt)
Willy Tarreau49b046d2012-08-09 12:11:58 +0200453 fd_stop_recv(listener->fd);
Willy Tarreaub648d632007-10-28 22:13:50 +0100454
Willy Tarreau01abd022019-02-28 10:27:18 +0100455 LIST_DEL_LOCKED(&listener->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200456
Willy Tarreaube58c382011-07-24 18:28:10 +0200457 if (listener->state >= LI_PAUSED) {
Olivier Houchard1fc05162017-04-06 01:05:05 +0200458 if (do_close) {
459 fd_delete(listener->fd);
460 listener->fd = -1;
461 }
462 else
463 fd_remove(listener->fd);
Willy Tarreaub648d632007-10-28 22:13:50 +0100464 listener->state = LI_ASSIGNED;
465 }
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100466}
467
Olivier Houchard1fc05162017-04-06 01:05:05 +0200468/* This function closes the listening socket for the specified listener,
469 * provided that it's already in a listening state. The listener enters the
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100470 * LI_ASSIGNED state. This function is intended to be used as a generic
471 * function for standard protocols.
Olivier Houchard1fc05162017-04-06 01:05:05 +0200472 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100473void unbind_listener(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200474{
Christopher Faulet510c0d62018-03-16 10:04:47 +0100475 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100476 do_unbind_listener(listener, 1);
Christopher Faulet510c0d62018-03-16 10:04:47 +0100477 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200478}
479
480/* This function pretends the listener is dead, but keeps the FD opened, so
481 * that we can provide it, for conf reloading.
482 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100483void unbind_listener_no_close(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200484{
Christopher Faulet510c0d62018-03-16 10:04:47 +0100485 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100486 do_unbind_listener(listener, 0);
Christopher Faulet510c0d62018-03-16 10:04:47 +0100487 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200488}
489
Willy Tarreau3acf8c32007-10-28 22:35:41 +0100490/* This function closes all listening sockets bound to the protocol <proto>,
491 * and the listeners end in LI_ASSIGNED state if they were higher. It does not
492 * detach them from the protocol. It always returns ERR_NONE.
493 */
494int unbind_all_listeners(struct protocol *proto)
495{
496 struct listener *listener;
497
498 list_for_each_entry(listener, &proto->listeners, proto_list)
499 unbind_listener(listener);
500 return ERR_NONE;
501}
502
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200503/* creates one or multiple listeners for bind_conf <bc> on sockaddr <ss> on port
504 * range <portl> to <porth>, and possibly attached to fd <fd> (or -1 for auto
505 * allocation). The address family is taken from ss->ss_family. The number of
506 * jobs and listeners is automatically increased by the number of listeners
William Lallemand75ea0a02017-11-15 19:02:58 +0100507 * created. If the <inherited> argument is set to 1, it specifies that the FD
508 * was obtained from a parent process.
509 * It returns non-zero on success, zero on error with the error message
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200510 * set in <err>.
511 */
512int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
William Lallemand75ea0a02017-11-15 19:02:58 +0100513 int portl, int porth, int fd, int inherited, char **err)
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200514{
515 struct protocol *proto = protocol_by_family(ss->ss_family);
516 struct listener *l;
517 int port;
518
519 if (!proto) {
520 memprintf(err, "unsupported protocol family %d", ss->ss_family);
521 return 0;
522 }
523
524 for (port = portl; port <= porth; port++) {
525 l = calloc(1, sizeof(*l));
526 if (!l) {
527 memprintf(err, "out of memory");
528 return 0;
529 }
530 l->obj_type = OBJ_TYPE_LISTENER;
531 LIST_ADDQ(&bc->frontend->conf.listeners, &l->by_fe);
532 LIST_ADDQ(&bc->listeners, &l->by_bind);
533 l->bind_conf = bc;
534
535 l->fd = fd;
536 memcpy(&l->addr, ss, sizeof(*ss));
Willy Tarreau01abd022019-02-28 10:27:18 +0100537 LIST_INIT(&l->wait_queue);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200538 l->state = LI_INIT;
539
540 proto->add(l, port);
541
William Lallemand75ea0a02017-11-15 19:02:58 +0100542 if (inherited)
543 l->options |= LI_O_INHERITED;
544
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100545 HA_SPIN_INIT(&l->lock);
Olivier Houchard64213e92019-03-08 18:52:57 +0100546 _HA_ATOMIC_ADD(&jobs, 1);
547 _HA_ATOMIC_ADD(&listeners, 1);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200548 }
549 return 1;
550}
551
Willy Tarreau1a64d162007-10-28 22:26:05 +0100552/* Delete a listener from its protocol's list of listeners. The listener's
553 * state is automatically updated from LI_ASSIGNED to LI_INIT. The protocol's
Willy Tarreau2cc5bae2017-09-15 08:18:11 +0200554 * number of listeners is updated, as well as the global number of listeners
555 * and jobs. Note that the listener must have previously been unbound. This
556 * is the generic function to use to remove a listener.
Willy Tarreau1a64d162007-10-28 22:26:05 +0100557 */
558void delete_listener(struct listener *listener)
559{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100560 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100561 if (listener->state == LI_ASSIGNED) {
562 listener->state = LI_INIT;
563 LIST_DEL(&listener->proto_list);
564 listener->proto->nb_listeners--;
Olivier Houchard64213e92019-03-08 18:52:57 +0100565 _HA_ATOMIC_SUB(&jobs, 1);
566 _HA_ATOMIC_SUB(&listeners, 1);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100567 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100568 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau1a64d162007-10-28 22:26:05 +0100569}
570
Willy Tarreaue2711c72019-02-27 15:39:41 +0100571/* Returns a suitable value for a listener's backlog. It uses the listener's,
572 * otherwise the frontend's backlog, otherwise the listener's maxconn,
573 * otherwise the frontend's maxconn, otherwise 1024.
574 */
575int listener_backlog(const struct listener *l)
576{
577 if (l->backlog)
578 return l->backlog;
579
580 if (l->bind_conf->frontend->backlog)
581 return l->bind_conf->frontend->backlog;
582
583 if (l->maxconn)
584 return l->maxconn;
585
586 if (l->bind_conf->frontend->maxconn)
587 return l->bind_conf->frontend->maxconn;
588
589 return 1024;
590}
591
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200592/* This function is called on a read event from a listening socket, corresponding
593 * to an accept. It tries to accept as many connections as possible, and for each
594 * calls the listener's accept handler (generally the frontend's accept handler).
595 */
Willy Tarreauafad0e02012-08-09 14:45:22 +0200596void listener_accept(int fd)
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200597{
598 struct listener *l = fdtab[fd].owner;
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100599 struct proxy *p;
600 int max_accept;
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100601 int next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100602 int next_feconn = 0;
603 int next_actconn = 0;
Willy Tarreaubb660302014-05-07 19:47:02 +0200604 int expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200605 int cfd;
606 int ret;
Willy Tarreau818dca52014-01-31 19:40:19 +0100607#ifdef USE_ACCEPT4
608 static int accept4_broken;
609#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200610
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100611 if (!l)
612 return;
613 p = l->bind_conf->frontend;
614 max_accept = l->maxaccept ? l->maxaccept : 1;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200615
Willy Tarreau93e7c002013-10-07 18:51:07 +0200616 if (!(l->options & LI_O_UNLIMITED) && global.sps_lim) {
617 int max = freq_ctr_remain(&global.sess_per_sec, global.sps_lim, 0);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200618
619 if (unlikely(!max)) {
620 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200621 expire = tick_add(now_ms, next_event_delay(&global.sess_per_sec, global.sps_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200622 goto wait_expire;
Willy Tarreau93e7c002013-10-07 18:51:07 +0200623 }
624
625 if (max_accept > max)
626 max_accept = max;
627 }
628
629 if (!(l->options & LI_O_UNLIMITED) && global.cps_lim) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200630 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
631
632 if (unlikely(!max)) {
633 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200634 expire = tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200635 goto wait_expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200636 }
637
638 if (max_accept > max)
639 max_accept = max;
640 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200641#ifdef USE_OPENSSL
642 if (!(l->options & LI_O_UNLIMITED) && global.ssl_lim && l->bind_conf && l->bind_conf->is_ssl) {
643 int max = freq_ctr_remain(&global.ssl_per_sec, global.ssl_lim, 0);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200644
Willy Tarreaue43d5322013-10-07 20:01:52 +0200645 if (unlikely(!max)) {
646 /* frontend accept rate limit was reached */
Willy Tarreaue43d5322013-10-07 20:01:52 +0200647 expire = tick_add(now_ms, next_event_delay(&global.ssl_per_sec, global.ssl_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200648 goto wait_expire;
Willy Tarreaue43d5322013-10-07 20:01:52 +0200649 }
650
651 if (max_accept > max)
652 max_accept = max;
653 }
654#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200655 if (p && p->fe_sps_lim) {
656 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
657
658 if (unlikely(!max)) {
659 /* frontend accept rate limit was reached */
660 limit_listener(l, &p->listener_queue);
661 task_schedule(p->task, tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0)));
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200662 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200663 }
664
665 if (max_accept > max)
666 max_accept = max;
667 }
668
669 /* Note: if we fail to allocate a connection because of configured
670 * limits, we'll schedule a new attempt worst 1 second later in the
671 * worst case. If we fail due to system limits or temporary resource
672 * shortage, we try again 100ms later in the worst case.
673 */
Willy Tarreau82c97892019-02-27 19:32:32 +0100674 for (; max_accept-- > 0; next_conn = next_feconn = next_actconn = 0) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200675 struct sockaddr_storage addr;
676 socklen_t laddr = sizeof(addr);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200677 unsigned int count;
Willy Tarreau57cb5062019-03-15 17:16:34 +0100678 __decl_hathreads(unsigned long mask);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200679
Willy Tarreau82c97892019-02-27 19:32:32 +0100680 /* pre-increase the number of connections without going too far.
681 * We process the listener, then the proxy, then the process.
682 * We know which ones to unroll based on the next_xxx value.
683 */
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100684 do {
685 count = l->nbconn;
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100686 if (l->maxconn && count >= l->maxconn) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100687 /* the listener was marked full or another
688 * thread is going to do it.
689 */
690 next_conn = 0;
691 goto end;
692 }
693 next_conn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000694 } while (!_HA_ATOMIC_CAS(&l->nbconn, (int *)(&count), next_conn));
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100695
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100696 if (l->maxconn && next_conn == l->maxconn) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100697 /* we filled it, mark it full */
698 listener_full(l);
699 }
700
Willy Tarreau82c97892019-02-27 19:32:32 +0100701 if (p) {
702 do {
703 count = p->feconn;
704 if (count >= p->maxconn) {
705 /* the frontend was marked full or another
706 * thread is going to do it.
707 */
708 next_feconn = 0;
709 goto end;
710 }
711 next_feconn = count + 1;
Olivier Houchard64213e92019-03-08 18:52:57 +0100712 } while (!_HA_ATOMIC_CAS(&p->feconn, &count, next_feconn));
Willy Tarreau82c97892019-02-27 19:32:32 +0100713
714 if (unlikely(next_feconn == p->maxconn)) {
715 /* we just filled it */
716 limit_listener(l, &p->listener_queue);
717 }
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200718 }
719
Willy Tarreau82c97892019-02-27 19:32:32 +0100720 if (!(l->options & LI_O_UNLIMITED)) {
721 do {
722 count = actconn;
723 if (count >= global.maxconn) {
724 /* the process was marked full or another
725 * thread is going to do it.
726 */
727 next_actconn = 0;
728 goto end;
729 }
730 next_actconn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000731 } while (!_HA_ATOMIC_CAS(&actconn, (int *)(&count), next_actconn));
Willy Tarreau82c97892019-02-27 19:32:32 +0100732
733 if (unlikely(next_actconn == global.maxconn)) {
734 limit_listener(l, &global_listener_queue);
735 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
736 }
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200737 }
738
William Lallemand2fe7dd02018-09-11 16:51:29 +0200739 /* with sockpair@ we don't want to do an accept */
740 if (unlikely(l->addr.ss_family == AF_CUST_SOCKPAIR)) {
741 if ((cfd = recv_fd_uxst(fd)) != -1)
William Lallemandd9138002018-11-27 12:02:39 +0100742 fcntl(cfd, F_SETFL, O_NONBLOCK);
Willy Tarreau888d5672019-01-27 18:34:12 +0100743 /* just like with UNIX sockets, only the family is filled */
744 addr.ss_family = AF_UNIX;
745 laddr = sizeof(addr.ss_family);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200746 } else
747
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200748#ifdef USE_ACCEPT4
Willy Tarreau818dca52014-01-31 19:40:19 +0100749 /* only call accept4() if it's known to be safe, otherwise
750 * fallback to the legacy accept() + fcntl().
751 */
752 if (unlikely(accept4_broken ||
William Lallemandd9138002018-11-27 12:02:39 +0100753 ((cfd = accept4(fd, (struct sockaddr *)&addr, &laddr, SOCK_NONBLOCK)) == -1 &&
Willy Tarreau818dca52014-01-31 19:40:19 +0100754 (errno == ENOSYS || errno == EINVAL || errno == EBADF) &&
755 (accept4_broken = 1))))
756#endif
Willy Tarreau6b3b0d42012-10-22 19:32:55 +0200757 if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) != -1)
William Lallemandd9138002018-11-27 12:02:39 +0100758 fcntl(cfd, F_SETFL, O_NONBLOCK);
Willy Tarreau818dca52014-01-31 19:40:19 +0100759
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200760 if (unlikely(cfd == -1)) {
761 switch (errno) {
762 case EAGAIN:
Willy Tarreaubb660302014-05-07 19:47:02 +0200763 if (fdtab[fd].ev & FD_POLL_HUP) {
764 /* the listening socket might have been disabled in a shared
765 * process and we're a collateral victim. We'll just pause for
766 * a while in case it comes back. In the mean time, we need to
767 * clear this sticky flag.
768 */
769 fdtab[fd].ev &= ~FD_POLL_HUP;
770 goto transient_error;
771 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100772 fd_cant_recv(fd);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200773 goto end; /* nothing more to accept */
Willy Tarreaubb660302014-05-07 19:47:02 +0200774 case EINVAL:
775 /* might be trying to accept on a shut fd (eg: soft stop) */
776 goto transient_error;
Willy Tarreaua593ec52014-01-20 21:21:30 +0100777 case EINTR:
778 case ECONNABORTED:
Olivier Houchard64213e92019-03-08 18:52:57 +0100779 _HA_ATOMIC_SUB(&l->nbconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +0100780 if (p)
Olivier Houchard64213e92019-03-08 18:52:57 +0100781 _HA_ATOMIC_SUB(&p->feconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +0100782 if (!(l->options & LI_O_UNLIMITED))
Olivier Houchard64213e92019-03-08 18:52:57 +0100783 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreaua593ec52014-01-20 21:21:30 +0100784 continue;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200785 case ENFILE:
786 if (p)
787 send_log(p, LOG_EMERG,
Willy Tarreauc5532ac2018-01-29 15:06:04 +0100788 "Proxy %s reached system FD limit (maxsock=%d). Please check system tunables.\n",
789 p->id, global.maxsock);
Willy Tarreaubb660302014-05-07 19:47:02 +0200790 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200791 case EMFILE:
792 if (p)
793 send_log(p, LOG_EMERG,
Willy Tarreauc5532ac2018-01-29 15:06:04 +0100794 "Proxy %s reached process FD limit (maxsock=%d). Please check 'ulimit-n' and restart.\n",
795 p->id, global.maxsock);
Willy Tarreaubb660302014-05-07 19:47:02 +0200796 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200797 case ENOBUFS:
798 case ENOMEM:
799 if (p)
800 send_log(p, LOG_EMERG,
Willy Tarreauc5532ac2018-01-29 15:06:04 +0100801 "Proxy %s reached system memory limit (maxsock=%d). Please check system tunables.\n",
802 p->id, global.maxsock);
Willy Tarreaubb660302014-05-07 19:47:02 +0200803 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200804 default:
Willy Tarreaua593ec52014-01-20 21:21:30 +0100805 /* unexpected result, let's give up and let other tasks run */
Willy Tarreau6c11bd22014-01-24 00:54:27 +0100806 goto stop;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200807 }
808 }
809
William Lallemandd9138002018-11-27 12:02:39 +0100810 /* we don't want to leak the FD upon reload if it's in the master */
811 if (unlikely(master == 1))
812 fcntl(cfd, F_SETFD, FD_CLOEXEC);
813
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100814 /* The connection was accepted, it must be counted as such */
815 if (l->counters)
816 HA_ATOMIC_UPDATE_MAX(&l->counters->conn_max, next_conn);
817
Willy Tarreau82c97892019-02-27 19:32:32 +0100818 if (p)
819 HA_ATOMIC_UPDATE_MAX(&p->fe_counters.conn_max, next_feconn);
820
821 proxy_inc_fe_conn_ctr(l, p);
822
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100823 if (!(l->options & LI_O_UNLIMITED)) {
824 count = update_freq_ctr(&global.conn_per_sec, 1);
825 HA_ATOMIC_UPDATE_MAX(&global.cps_max, count);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100826 }
827
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200828 if (unlikely(cfd >= global.maxsock)) {
829 send_log(p, LOG_EMERG,
830 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
831 p->id);
832 close(cfd);
833 limit_listener(l, &global_listener_queue);
834 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200835 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200836 }
837
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100838 /* past this point, l->accept() will automatically decrement
Willy Tarreau82c97892019-02-27 19:32:32 +0100839 * l->nbconn, feconn and actconn once done. Setting next_*conn=0
840 * allows the error path not to rollback on nbconn. It's more
841 * convenient than duplicating all exit labels.
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100842 */
843 next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100844 next_feconn = 0;
845 next_actconn = 0;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200846
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100847#if defined(USE_THREAD)
Willy Tarreau897e2c52019-03-13 15:03:53 +0100848 mask = thread_mask(l->bind_conf->bind_thread) & all_threads_mask;
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100849 if (atleast2(mask) && (global.tune.options & GTUNE_LISTENER_MQ)) {
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100850 struct accept_queue_ring *ring;
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100851 unsigned int t, t0, t1, t2;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100852
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100853 /* The principle is that we have two running indexes,
854 * each visiting in turn all threads bound to this
855 * listener. The connection will be assigned to the one
856 * with the least connections, and the other one will
857 * be updated. This provides a good fairness on short
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100858 * connections (round robin) and on long ones (conn
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100859 * count), without ever missing any idle thread.
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100860 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100861
862 /* keep a copy for the final update. thr_idx is composite
863 * and made of (t2<<16) + t1.
864 */
Willy Tarreau0cf33172019-03-06 15:26:33 +0100865 t0 = l->thr_idx;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100866 do {
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100867 unsigned long m1, m2;
868 int q1, q2;
869
870 t2 = t1 = t0;
871 t2 >>= 16;
872 t1 &= 0xFFFF;
873
874 /* t1 walks low to high bits ;
875 * t2 walks high to low.
876 */
877 m1 = mask >> t1;
878 m2 = mask & (t2 ? nbits(t2 + 1) : ~0UL);
879
880 if (unlikely((signed long)m2 >= 0)) {
881 /* highest bit not set */
882 if (!m2)
883 m2 = mask;
884
885 t2 = my_flsl(m2) - 1;
886 }
887
888 if (unlikely(!(m1 & 1) || t1 == t2)) {
889 m1 &= ~1UL;
890 if (!m1) {
891 m1 = mask;
892 t1 = 0;
893 }
894 t1 += my_ffsl(m1) - 1;
895 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100896
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100897 /* now we have two distinct thread IDs belonging to the mask */
898 q1 = accept_queue_rings[t1].tail - accept_queue_rings[t1].head + ACCEPT_QUEUE_SIZE;
899 if (q1 >= ACCEPT_QUEUE_SIZE)
900 q1 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100901
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100902 q2 = accept_queue_rings[t2].tail - accept_queue_rings[t2].head + ACCEPT_QUEUE_SIZE;
903 if (q2 >= ACCEPT_QUEUE_SIZE)
904 q2 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100905
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100906 /* we have 3 possibilities now :
907 * q1 < q2 : t1 is less loaded than t2, so we pick it
908 * and update t2 (since t1 might still be
909 * lower than another thread)
910 * q1 > q2 : t2 is less loaded than t1, so we pick it
911 * and update t1 (since t2 might still be
912 * lower than another thread)
913 * q1 = q2 : both are equally loaded, thus we pick t1
914 * and update t1 as it will become more loaded
915 * than t2.
916 */
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100917
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100918 q1 += l->thr_conn[t1];
919 q2 += l->thr_conn[t2];
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100920
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100921 if (q1 - q2 < 0) {
922 t = t1;
923 t2 = t2 ? t2 - 1 : LONGBITS - 1;
924 }
925 else if (q1 - q2 > 0) {
926 t = t2;
927 t1++;
928 if (t1 >= LONGBITS)
929 t1 = 0;
930 }
931 else {
932 t = t1;
933 t1++;
934 if (t1 >= LONGBITS)
935 t1 = 0;
936 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100937
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100938 /* new value for thr_idx */
939 t1 += (t2 << 16);
Olivier Houchard64213e92019-03-08 18:52:57 +0100940 } while (unlikely(!_HA_ATOMIC_CAS(&l->thr_idx, &t0, t1)));
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100941
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100942 /* We successfully selected the best thread "t" for this
943 * connection. We use deferred accepts even if it's the
944 * local thread because tests show that it's the best
945 * performing model, likely due to better cache locality
946 * when processing this loop.
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100947 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100948 ring = &accept_queue_rings[t];
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100949 if (accept_queue_push_mp(ring, cfd, l, &addr, laddr)) {
Olivier Houchard64213e92019-03-08 18:52:57 +0100950 _HA_ATOMIC_ADD(&activity[t].accq_pushed, 1);
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100951 task_wakeup(ring->task, TASK_WOKEN_IO);
952 continue;
953 }
954 /* If the ring is full we do a synchronous accept on
955 * the local thread here.
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100956 */
Olivier Houchard64213e92019-03-08 18:52:57 +0100957 _HA_ATOMIC_ADD(&activity[t].accq_full, 1);
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100958 }
959#endif // USE_THREAD
960
Olivier Houchard64213e92019-03-08 18:52:57 +0100961 _HA_ATOMIC_ADD(&l->thr_conn[tid], 1);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200962 ret = l->accept(l, cfd, &addr);
963 if (unlikely(ret <= 0)) {
Willy Tarreau87b09662015-04-03 00:22:06 +0200964 /* The connection was closed by stream_accept(). Either
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200965 * we just have to ignore it (ret == 0) or it's a critical
966 * error due to a resource shortage, and we must stop the
967 * listener (ret < 0).
968 */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200969 if (ret == 0) /* successful termination */
970 continue;
971
Willy Tarreaubb660302014-05-07 19:47:02 +0200972 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200973 }
974
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100975 /* increase the per-process number of cumulated sessions, this
976 * may only be done once l->accept() has accepted the connection.
977 */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200978 if (!(l->options & LI_O_UNLIMITED)) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200979 count = update_freq_ctr(&global.sess_per_sec, 1);
980 HA_ATOMIC_UPDATE_MAX(&global.sps_max, count);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200981 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200982#ifdef USE_OPENSSL
983 if (!(l->options & LI_O_UNLIMITED) && l->bind_conf && l->bind_conf->is_ssl) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200984 count = update_freq_ctr(&global.ssl_per_sec, 1);
985 HA_ATOMIC_UPDATE_MAX(&global.ssl_max, count);
Willy Tarreaue43d5322013-10-07 20:01:52 +0200986 }
987#endif
Willy Tarreau93e7c002013-10-07 18:51:07 +0200988
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100989 } /* end of for (max_accept--) */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200990
Willy Tarreauaece46a2012-07-06 12:25:58 +0200991 /* we've exhausted max_accept, so there is no need to poll again */
Willy Tarreau6c11bd22014-01-24 00:54:27 +0100992 stop:
993 fd_done_recv(fd);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200994 goto end;
Willy Tarreaubb660302014-05-07 19:47:02 +0200995
996 transient_error:
997 /* pause the listener and try again in 100 ms */
998 expire = tick_add(now_ms, 100);
999
1000 wait_expire:
1001 limit_listener(l, &global_listener_queue);
1002 task_schedule(global_listener_queue_task, tick_first(expire, global_listener_queue_task->expire));
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001003 end:
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001004 if (next_conn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001005 _HA_ATOMIC_SUB(&l->nbconn, 1);
Willy Tarreau741b4d62019-02-25 15:02:04 +01001006
Willy Tarreau82c97892019-02-27 19:32:32 +01001007 if (p && next_feconn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001008 _HA_ATOMIC_SUB(&p->feconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001009
1010 if (next_actconn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001011 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001012
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001013 if ((l->state == LI_FULL && (!l->maxconn || l->nbconn < l->maxconn)) ||
Willy Tarreau82c97892019-02-27 19:32:32 +01001014 (l->state == LI_LIMITED && ((!p || p->feconn < p->maxconn) && (actconn < global.maxconn)))) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001015 /* at least one thread has to this when quitting */
1016 resume_listener(l);
1017
1018 /* Dequeues all of the listeners waiting for a resource */
1019 if (!LIST_ISEMPTY(&global_listener_queue))
1020 dequeue_all_listeners(&global_listener_queue);
1021
1022 if (!LIST_ISEMPTY(&p->listener_queue) &&
1023 (!p->fe_sps_lim || freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0) > 0))
1024 dequeue_all_listeners(&p->listener_queue);
1025 }
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001026}
1027
Willy Tarreau05f50472017-09-15 09:19:58 +02001028/* Notify the listener that a connection initiated from it was released. This
1029 * is used to keep the connection count consistent and to possibly re-open
1030 * listening when it was limited.
1031 */
1032void listener_release(struct listener *l)
1033{
1034 struct proxy *fe = l->bind_conf->frontend;
1035
1036 if (!(l->options & LI_O_UNLIMITED))
Olivier Houchard64213e92019-03-08 18:52:57 +01001037 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001038 if (fe)
Olivier Houchard64213e92019-03-08 18:52:57 +01001039 _HA_ATOMIC_SUB(&fe->feconn, 1);
1040 _HA_ATOMIC_SUB(&l->nbconn, 1);
1041 _HA_ATOMIC_SUB(&l->thr_conn[tid], 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001042
1043 if (l->state == LI_FULL || l->state == LI_LIMITED)
Willy Tarreau05f50472017-09-15 09:19:58 +02001044 resume_listener(l);
1045
1046 /* Dequeues all of the listeners waiting for a resource */
1047 if (!LIST_ISEMPTY(&global_listener_queue))
1048 dequeue_all_listeners(&global_listener_queue);
1049
1050 if (!LIST_ISEMPTY(&fe->listener_queue) &&
1051 (!fe->fe_sps_lim || freq_ctr_remain(&fe->fe_sess_per_sec, fe->fe_sps_lim, 0) > 0))
1052 dequeue_all_listeners(&fe->listener_queue);
1053}
1054
Willy Tarreau26982662012-09-12 23:17:10 +02001055/*
1056 * Registers the bind keyword list <kwl> as a list of valid keywords for next
1057 * parsing sessions.
1058 */
1059void bind_register_keywords(struct bind_kw_list *kwl)
1060{
1061 LIST_ADDQ(&bind_keywords.list, &kwl->list);
1062}
1063
1064/* Return a pointer to the bind keyword <kw>, or NULL if not found. If the
1065 * keyword is found with a NULL ->parse() function, then an attempt is made to
1066 * find one with a valid ->parse() function. This way it is possible to declare
1067 * platform-dependant, known keywords as NULL, then only declare them as valid
1068 * if some options are met. Note that if the requested keyword contains an
1069 * opening parenthesis, everything from this point is ignored.
1070 */
1071struct bind_kw *bind_find_kw(const char *kw)
1072{
1073 int index;
1074 const char *kwend;
1075 struct bind_kw_list *kwl;
1076 struct bind_kw *ret = NULL;
1077
1078 kwend = strchr(kw, '(');
1079 if (!kwend)
1080 kwend = kw + strlen(kw);
1081
1082 list_for_each_entry(kwl, &bind_keywords.list, list) {
1083 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1084 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
1085 kwl->kw[index].kw[kwend-kw] == 0) {
1086 if (kwl->kw[index].parse)
1087 return &kwl->kw[index]; /* found it !*/
1088 else
1089 ret = &kwl->kw[index]; /* may be OK */
1090 }
1091 }
1092 }
1093 return ret;
1094}
1095
Willy Tarreau8638f482012-09-18 18:01:17 +02001096/* Dumps all registered "bind" keywords to the <out> string pointer. The
1097 * unsupported keywords are only dumped if their supported form was not
1098 * found.
1099 */
1100void bind_dump_kws(char **out)
1101{
1102 struct bind_kw_list *kwl;
1103 int index;
1104
1105 *out = NULL;
1106 list_for_each_entry(kwl, &bind_keywords.list, list) {
1107 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1108 if (kwl->kw[index].parse ||
1109 bind_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
Willy Tarreau51fb7652012-09-18 18:24:39 +02001110 memprintf(out, "%s[%4s] %s%s%s\n", *out ? *out : "",
1111 kwl->scope,
Willy Tarreau8638f482012-09-18 18:01:17 +02001112 kwl->kw[index].kw,
Willy Tarreau51fb7652012-09-18 18:24:39 +02001113 kwl->kw[index].skip ? " <arg>" : "",
1114 kwl->kw[index].parse ? "" : " (not supported)");
Willy Tarreau8638f482012-09-18 18:01:17 +02001115 }
1116 }
1117 }
1118}
1119
Willy Tarreau645513a2010-05-24 20:55:15 +02001120/************************************************************************/
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001121/* All supported sample and ACL keywords must be declared here. */
Willy Tarreau645513a2010-05-24 20:55:15 +02001122/************************************************************************/
1123
Willy Tarreaua5e37562011-12-16 17:06:15 +01001124/* set temp integer to the number of connexions to the same listening socket */
Willy Tarreau645513a2010-05-24 20:55:15 +02001125static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001126smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau645513a2010-05-24 20:55:15 +02001127{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001128 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001129 smp->data.u.sint = smp->sess->listener->nbconn;
Willy Tarreau645513a2010-05-24 20:55:15 +02001130 return 1;
1131}
1132
Willy Tarreaua5e37562011-12-16 17:06:15 +01001133/* set temp integer to the id of the socket (listener) */
Willy Tarreau645513a2010-05-24 20:55:15 +02001134static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001135smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau37406352012-04-23 16:16:37 +02001136{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001137 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001138 smp->data.u.sint = smp->sess->listener->luid;
Willy Tarreau645513a2010-05-24 20:55:15 +02001139 return 1;
1140}
1141
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001142/* parse the "accept-proxy" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001143static int bind_parse_accept_proxy(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001144{
1145 struct listener *l;
1146
Willy Tarreau4348fad2012-09-20 16:48:07 +02001147 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001148 l->options |= LI_O_ACC_PROXY;
1149
1150 return 0;
1151}
1152
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001153/* parse the "accept-netscaler-cip" bind keyword */
1154static int bind_parse_accept_netscaler_cip(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1155{
1156 struct listener *l;
1157 uint32_t val;
1158
1159 if (!*args[cur_arg + 1]) {
1160 memprintf(err, "'%s' : missing value", args[cur_arg]);
1161 return ERR_ALERT | ERR_FATAL;
1162 }
1163
1164 val = atol(args[cur_arg + 1]);
1165 if (val <= 0) {
Willy Tarreaue2711c72019-02-27 15:39:41 +01001166 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001167 return ERR_ALERT | ERR_FATAL;
1168 }
1169
1170 list_for_each_entry(l, &conf->listeners, by_bind) {
1171 l->options |= LI_O_ACC_CIP;
1172 conf->ns_cip_magic = val;
1173 }
1174
1175 return 0;
1176}
1177
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001178/* parse the "backlog" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001179static int bind_parse_backlog(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001180{
1181 struct listener *l;
1182 int val;
1183
1184 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001185 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001186 return ERR_ALERT | ERR_FATAL;
1187 }
1188
1189 val = atol(args[cur_arg + 1]);
Willy Tarreaue2711c72019-02-27 15:39:41 +01001190 if (val < 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001191 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001192 return ERR_ALERT | ERR_FATAL;
1193 }
1194
Willy Tarreau4348fad2012-09-20 16:48:07 +02001195 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001196 l->backlog = val;
1197
1198 return 0;
1199}
1200
1201/* parse the "id" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001202static int bind_parse_id(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001203{
1204 struct eb32_node *node;
Willy Tarreau4348fad2012-09-20 16:48:07 +02001205 struct listener *l, *new;
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001206 char *error;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001207
Willy Tarreau4348fad2012-09-20 16:48:07 +02001208 if (conf->listeners.n != conf->listeners.p) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001209 memprintf(err, "'%s' can only be used with a single socket", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001210 return ERR_ALERT | ERR_FATAL;
1211 }
1212
1213 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001214 memprintf(err, "'%s' : expects an integer argument", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001215 return ERR_ALERT | ERR_FATAL;
1216 }
1217
Willy Tarreau4348fad2012-09-20 16:48:07 +02001218 new = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001219 new->luid = strtol(args[cur_arg + 1], &error, 10);
1220 if (*error != '\0') {
1221 memprintf(err, "'%s' : expects an integer argument, found '%s'", args[cur_arg], args[cur_arg + 1]);
1222 return ERR_ALERT | ERR_FATAL;
1223 }
Willy Tarreau4348fad2012-09-20 16:48:07 +02001224 new->conf.id.key = new->luid;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001225
Willy Tarreau4348fad2012-09-20 16:48:07 +02001226 if (new->luid <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001227 memprintf(err, "'%s' : custom id has to be > 0", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001228 return ERR_ALERT | ERR_FATAL;
1229 }
1230
Willy Tarreau4348fad2012-09-20 16:48:07 +02001231 node = eb32_lookup(&px->conf.used_listener_id, new->luid);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001232 if (node) {
1233 l = container_of(node, struct listener, conf.id);
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001234 memprintf(err, "'%s' : custom id %d already used at %s:%d ('bind %s')",
1235 args[cur_arg], l->luid, l->bind_conf->file, l->bind_conf->line,
1236 l->bind_conf->arg);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001237 return ERR_ALERT | ERR_FATAL;
1238 }
1239
Willy Tarreau4348fad2012-09-20 16:48:07 +02001240 eb32_insert(&px->conf.used_listener_id, &new->conf.id);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001241 return 0;
1242}
1243
1244/* parse the "maxconn" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001245static int bind_parse_maxconn(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001246{
1247 struct listener *l;
1248 int val;
1249
1250 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001251 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001252 return ERR_ALERT | ERR_FATAL;
1253 }
1254
1255 val = atol(args[cur_arg + 1]);
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001256 if (val < 0) {
1257 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001258 return ERR_ALERT | ERR_FATAL;
1259 }
1260
Willy Tarreau4348fad2012-09-20 16:48:07 +02001261 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001262 l->maxconn = val;
1263
1264 return 0;
1265}
1266
1267/* parse the "name" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001268static int bind_parse_name(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001269{
1270 struct listener *l;
1271
1272 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001273 memprintf(err, "'%s' : missing name", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001274 return ERR_ALERT | ERR_FATAL;
1275 }
1276
Willy Tarreau4348fad2012-09-20 16:48:07 +02001277 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001278 l->name = strdup(args[cur_arg + 1]);
1279
1280 return 0;
1281}
1282
1283/* parse the "nice" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001284static int bind_parse_nice(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001285{
1286 struct listener *l;
1287 int val;
1288
1289 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001290 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001291 return ERR_ALERT | ERR_FATAL;
1292 }
1293
1294 val = atol(args[cur_arg + 1]);
1295 if (val < -1024 || val > 1024) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001296 memprintf(err, "'%s' : invalid value %d, allowed range is -1024..1024", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001297 return ERR_ALERT | ERR_FATAL;
1298 }
1299
Willy Tarreau4348fad2012-09-20 16:48:07 +02001300 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001301 l->nice = val;
1302
1303 return 0;
1304}
1305
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001306/* parse the "process" bind keyword */
1307static int bind_parse_process(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1308{
Christopher Fauletc644fa92017-11-23 22:44:11 +01001309 char *slash;
1310 unsigned long proc = 0, thread = 0;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001311
Christopher Fauletc644fa92017-11-23 22:44:11 +01001312 if ((slash = strchr(args[cur_arg + 1], '/')) != NULL)
1313 *slash = 0;
1314
Willy Tarreauff9c9142019-02-07 10:39:36 +01001315 if (parse_process_number(args[cur_arg + 1], &proc, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +01001316 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001317 return ERR_ALERT | ERR_FATAL;
1318 }
1319
Christopher Fauletc644fa92017-11-23 22:44:11 +01001320 if (slash) {
Willy Tarreauc9a82e42019-01-26 13:25:14 +01001321 if (parse_process_number(slash+1, &thread, MAX_THREADS, NULL, err)) {
Christopher Fauletc644fa92017-11-23 22:44:11 +01001322 memprintf(err, "'%s' : %s", args[cur_arg], *err);
1323 return ERR_ALERT | ERR_FATAL;
1324 }
1325 *slash = '/';
1326 }
1327
1328 conf->bind_proc |= proc;
Willy Tarreaua36b3242019-02-02 13:14:34 +01001329 conf->bind_thread |= thread;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001330 return 0;
1331}
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001332
Christopher Fauleta717b992018-04-10 14:43:00 +02001333/* parse the "proto" bind keyword */
1334static int bind_parse_proto(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1335{
1336 struct ist proto;
1337
1338 if (!*args[cur_arg + 1]) {
1339 memprintf(err, "'%s' : missing value", args[cur_arg]);
1340 return ERR_ALERT | ERR_FATAL;
1341 }
1342
1343 proto = ist2(args[cur_arg + 1], strlen(args[cur_arg + 1]));
1344 conf->mux_proto = get_mux_proto(proto);
1345 if (!conf->mux_proto) {
1346 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[cur_arg], args[cur_arg+1]);
1347 return ERR_ALERT | ERR_FATAL;
1348 }
Christopher Fauleta717b992018-04-10 14:43:00 +02001349 return 0;
1350}
1351
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001352/* config parser for global "tune.listener.multi-queue", accepts "on" or "off" */
1353static int cfg_parse_tune_listener_mq(char **args, int section_type, struct proxy *curpx,
1354 struct proxy *defpx, const char *file, int line,
1355 char **err)
1356{
1357 if (too_many_args(1, args, err, NULL))
1358 return -1;
1359
1360 if (strcmp(args[1], "on") == 0)
1361 global.tune.options |= GTUNE_LISTENER_MQ;
1362 else if (strcmp(args[1], "off") == 0)
1363 global.tune.options &= ~GTUNE_LISTENER_MQ;
1364 else {
1365 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
1366 return -1;
1367 }
1368 return 0;
1369}
1370
Willy Tarreau61612d42012-04-19 18:42:05 +02001371/* Note: must not be declared <const> as its list will be overwritten.
1372 * Please take care of keeping this list alphabetically sorted.
1373 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001374static struct sample_fetch_kw_list smp_kws = {ILH, {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001375 { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
1376 { "so_id", smp_fetch_so_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001377 { /* END */ },
1378}};
1379
Willy Tarreau0108d902018-11-25 19:14:37 +01001380INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1381
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001382/* Note: must not be declared <const> as its list will be overwritten.
1383 * Please take care of keeping this list alphabetically sorted.
1384 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001385static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001386 { /* END */ },
Willy Tarreau645513a2010-05-24 20:55:15 +02001387}};
1388
Willy Tarreau0108d902018-11-25 19:14:37 +01001389INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
1390
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001391/* Note: must not be declared <const> as its list will be overwritten.
1392 * Please take care of keeping this list alphabetically sorted, doing so helps
1393 * all code contributors.
1394 * Optional keywords are also declared with a NULL ->parse() function so that
1395 * the config parser can report an appropriate error when a known keyword was
1396 * not enabled.
1397 */
Willy Tarreau51fb7652012-09-18 18:24:39 +02001398static struct bind_kw_list bind_kws = { "ALL", { }, {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001399 { "accept-netscaler-cip", bind_parse_accept_netscaler_cip, 1 }, /* enable NetScaler Client IP insertion protocol */
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001400 { "accept-proxy", bind_parse_accept_proxy, 0 }, /* enable PROXY protocol */
1401 { "backlog", bind_parse_backlog, 1 }, /* set backlog of listening socket */
1402 { "id", bind_parse_id, 1 }, /* set id of listening socket */
1403 { "maxconn", bind_parse_maxconn, 1 }, /* set maxconn of listening socket */
1404 { "name", bind_parse_name, 1 }, /* set name of listening socket */
1405 { "nice", bind_parse_nice, 1 }, /* set nice of listening socket */
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001406 { "process", bind_parse_process, 1 }, /* set list of allowed process for this socket */
Christopher Fauleta717b992018-04-10 14:43:00 +02001407 { "proto", bind_parse_proto, 1 }, /* set the proto to use for all incoming connections */
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001408 { /* END */ },
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001409}};
1410
Willy Tarreau0108d902018-11-25 19:14:37 +01001411INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
1412
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001413/* config keyword parsers */
1414static struct cfg_kw_list cfg_kws = {ILH, {
1415 { CFG_GLOBAL, "tune.listener.multi-queue", cfg_parse_tune_listener_mq },
1416 { 0, NULL, NULL }
1417}};
1418
1419INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1420
Willy Tarreau645513a2010-05-24 20:55:15 +02001421/*
1422 * Local variables:
1423 * c-indent-level: 8
1424 * c-basic-offset: 8
1425 * End:
1426 */