blob: 53039bb60d03dbd225992e1c69f3f74a44a3385e [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 Tarreau6ae1ba62014-05-07 19:01:58 +020013#include <ctype.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020014#include <errno.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020015#include <stdio.h>
16#include <string.h>
Willy Tarreau95ccdde2014-02-01 09:28:36 +010017#include <unistd.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020018
Willy Tarreaudcc048a2020-06-04 19:11:43 +020019#include <haproxy/acl.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020020#include <haproxy/api.h>
Willy Tarreau5d9ddc52021-10-06 19:54:09 +020021#include <haproxy/activity.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020022#include <haproxy/cfgparse.h>
Willy Tarreaudbf78022021-10-06 09:05:08 +020023#include <haproxy/cli-t.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020024#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020025#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020026#include <haproxy/fd.h>
27#include <haproxy/freq_ctr.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020028#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020029#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020030#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020031#include <haproxy/log.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020032#include <haproxy/protocol.h>
Willy Tarreau5958c432021-05-08 20:30:37 +020033#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020034#include <haproxy/sample.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020035#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020036#include <haproxy/task.h>
Willy Tarreau9310f482021-10-06 16:18:40 +020037#include <haproxy/ticks.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020038#include <haproxy/tools.h>
Willy Tarreau78d0dcd2022-05-20 17:10:00 +020039#include <haproxy/xprt_quic.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020040
Willy Tarreaub648d632007-10-28 22:13:50 +010041
Willy Tarreau26982662012-09-12 23:17:10 +020042/* List head of all known bind keywords */
Willy Tarreauca1acd62022-03-29 15:02:44 +020043struct bind_kw_list bind_keywords = {
Willy Tarreau26982662012-09-12 23:17:10 +020044 .list = LIST_HEAD_INIT(bind_keywords.list)
45};
46
Willy Tarreaua1d97f82019-12-10 11:18:41 +010047/* list of the temporarily limited listeners because of lack of resource */
48static struct mt_list global_listener_queue = MT_LIST_HEAD_INIT(global_listener_queue);
49static struct task *global_listener_queue_task;
Willy Tarreaua1d97f82019-12-10 11:18:41 +010050
William Dauchy3679d0c2021-02-14 23:22:55 +010051/* listener status for stats */
52const char* li_status_st[LI_STATE_COUNT] = {
53 [LI_STATUS_WAITING] = "WAITING",
54 [LI_STATUS_OPEN] = "OPEN",
55 [LI_STATUS_FULL] = "FULL",
56};
Willy Tarreaua1d97f82019-12-10 11:18:41 +010057
Willy Tarreau1efafce2019-01-27 15:37:19 +010058#if defined(USE_THREAD)
59
60struct accept_queue_ring accept_queue_rings[MAX_THREADS] __attribute__((aligned(64))) = { };
61
62/* dequeue and process a pending connection from the local accept queue (single
Willy Tarreau83efc322020-10-14 17:37:17 +020063 * consumer). Returns the accepted connection or NULL if none was found.
Willy Tarreau1efafce2019-01-27 15:37:19 +010064 */
Willy Tarreau83efc322020-10-14 17:37:17 +020065struct connection *accept_queue_pop_sc(struct accept_queue_ring *ring)
Willy Tarreau1efafce2019-01-27 15:37:19 +010066{
Willy Tarreau1efafce2019-01-27 15:37:19 +010067 unsigned int pos, next;
Willy Tarreau83efc322020-10-14 17:37:17 +020068 struct connection *ptr;
69 struct connection **e;
Willy Tarreau1efafce2019-01-27 15:37:19 +010070
71 pos = ring->head;
72
73 if (pos == ring->tail)
Willy Tarreau83efc322020-10-14 17:37:17 +020074 return NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +010075
76 next = pos + 1;
77 if (next >= ACCEPT_QUEUE_SIZE)
78 next = 0;
79
80 e = &ring->entry[pos];
81
82 /* wait for the producer to update the listener's pointer */
83 while (1) {
Willy Tarreau83efc322020-10-14 17:37:17 +020084 ptr = *e;
Willy Tarreau1efafce2019-01-27 15:37:19 +010085 __ha_barrier_load();
86 if (ptr)
87 break;
88 pl_cpu_relax();
89 }
90
Willy Tarreau1efafce2019-01-27 15:37:19 +010091 /* release the entry */
Willy Tarreau83efc322020-10-14 17:37:17 +020092 *e = NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +010093
94 __ha_barrier_store();
95 ring->head = next;
Willy Tarreau83efc322020-10-14 17:37:17 +020096 return ptr;
Willy Tarreau1efafce2019-01-27 15:37:19 +010097}
98
99
Willy Tarreau83efc322020-10-14 17:37:17 +0200100/* tries to push a new accepted connection <conn> into ring <ring>. Returns
101 * non-zero if it succeeds, or zero if the ring is full. Supports multiple
102 * producers.
Willy Tarreau1efafce2019-01-27 15:37:19 +0100103 */
Willy Tarreau83efc322020-10-14 17:37:17 +0200104int accept_queue_push_mp(struct accept_queue_ring *ring, struct connection *conn)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100105{
Willy Tarreau1efafce2019-01-27 15:37:19 +0100106 unsigned int pos, next;
107
108 pos = ring->tail;
109 do {
110 next = pos + 1;
111 if (next >= ACCEPT_QUEUE_SIZE)
112 next = 0;
113 if (next == ring->head)
114 return 0; // ring full
Olivier Houchard64213e92019-03-08 18:52:57 +0100115 } while (unlikely(!_HA_ATOMIC_CAS(&ring->tail, &pos, next)));
Willy Tarreau1efafce2019-01-27 15:37:19 +0100116
Willy Tarreau83efc322020-10-14 17:37:17 +0200117 ring->entry[pos] = conn;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100118 __ha_barrier_store();
Willy Tarreau1efafce2019-01-27 15:37:19 +0100119 return 1;
120}
121
Willy Tarreaufb5401f2021-01-29 12:25:23 +0100122/* proceed with accepting new connections. Don't mark it static so that it appears
123 * in task dumps.
124 */
Willy Tarreau144f84a2021-03-02 16:09:26 +0100125struct task *accept_queue_process(struct task *t, void *context, unsigned int state)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100126{
127 struct accept_queue_ring *ring = context;
Willy Tarreau83efc322020-10-14 17:37:17 +0200128 struct connection *conn;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100129 struct listener *li;
Christopher Faulet102854c2019-04-30 12:17:13 +0200130 unsigned int max_accept;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100131 int ret;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100132
Christopher Faulet102854c2019-04-30 12:17:13 +0200133 /* if global.tune.maxaccept is -1, then max_accept is UINT_MAX. It
134 * is not really illimited, but it is probably enough.
135 */
Willy Tarreau66161322021-02-19 15:50:27 +0100136 max_accept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Christopher Faulet102854c2019-04-30 12:17:13 +0200137 for (; max_accept; max_accept--) {
Willy Tarreau83efc322020-10-14 17:37:17 +0200138 conn = accept_queue_pop_sc(ring);
139 if (!conn)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100140 break;
141
Willy Tarreau83efc322020-10-14 17:37:17 +0200142 li = __objt_listener(conn->target);
Willy Tarreau4781b152021-04-06 13:53:36 +0200143 _HA_ATOMIC_INC(&li->thr_conn[tid]);
Willy Tarreau83efc322020-10-14 17:37:17 +0200144 ret = li->accept(conn);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100145 if (ret <= 0) {
146 /* connection was terminated by the application */
147 continue;
148 }
149
150 /* increase the per-process number of cumulated sessions, this
151 * may only be done once l->accept() has accepted the connection.
152 */
153 if (!(li->options & LI_O_UNLIMITED)) {
154 HA_ATOMIC_UPDATE_MAX(&global.sps_max,
155 update_freq_ctr(&global.sess_per_sec, 1));
Willy Tarreau11ba4042022-05-20 15:56:32 +0200156 if (li->bind_conf && li->bind_conf->options & BC_O_USE_SSL) {
Willy Tarreau1efafce2019-01-27 15:37:19 +0100157 HA_ATOMIC_UPDATE_MAX(&global.ssl_max,
158 update_freq_ctr(&global.ssl_per_sec, 1));
159 }
160 }
161 }
162
163 /* ran out of budget ? Let's come here ASAP */
Christopher Faulet102854c2019-04-30 12:17:13 +0200164 if (!max_accept)
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200165 tasklet_wakeup(ring->tasklet);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100166
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200167 return NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100168}
169
170/* Initializes the accept-queues. Returns 0 on success, otherwise ERR_* flags */
171static int accept_queue_init()
172{
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200173 struct tasklet *t;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100174 int i;
175
176 for (i = 0; i < global.nbthread; i++) {
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200177 t = tasklet_new();
Willy Tarreau1efafce2019-01-27 15:37:19 +0100178 if (!t) {
179 ha_alert("Out of memory while initializing accept queue for thread %d\n", i);
180 return ERR_FATAL|ERR_ABORT;
181 }
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200182 t->tid = i;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100183 t->process = accept_queue_process;
184 t->context = &accept_queue_rings[i];
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200185 accept_queue_rings[i].tasklet = t;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100186 }
187 return 0;
188}
189
190REGISTER_CONFIG_POSTPARSER("multi-threaded accept queue", accept_queue_init);
191
Willy Tarreaue01b08d2022-04-27 18:42:47 +0200192static void accept_queue_deinit()
193{
194 int i;
195
196 for (i = 0; i < global.nbthread; i++) {
197 if (accept_queue_rings[i].tasklet)
198 tasklet_free(accept_queue_rings[i].tasklet);
199 }
200}
201
202REGISTER_POST_DEINIT(accept_queue_deinit);
203
Willy Tarreau1efafce2019-01-27 15:37:19 +0100204#endif // USE_THREAD
205
Amaury Denoyellef68b2cb2022-01-25 16:21:47 +0100206/* Memory allocation and initialization of the per_thr field.
207 * Returns 0 if the field has been successfully initialized, -1 on failure.
208 */
209int li_init_per_thr(struct listener *li)
210{
211 int i;
212
213 /* allocate per-thread elements for listener */
214 li->per_thr = calloc(global.nbthread, sizeof(*li->per_thr));
215 if (!li->per_thr)
216 return -1;
217
218 for (i = 0; i < global.nbthread; ++i) {
219 MT_LIST_INIT(&li->per_thr[i].quic_accept.list);
220 MT_LIST_INIT(&li->per_thr[i].quic_accept.conns);
221
222 li->per_thr[i].li = li;
223 }
224
225 return 0;
226}
227
William Dauchy3679d0c2021-02-14 23:22:55 +0100228/* helper to get listener status for stats */
229enum li_status get_li_status(struct listener *l)
230{
231 if (!l->maxconn || l->nbconn < l->maxconn) {
232 if (l->state == LI_LIMITED)
233 return LI_STATUS_WAITING;
234 else
235 return LI_STATUS_OPEN;
236 }
237 return LI_STATUS_FULL;
238}
239
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200240/* adjust the listener's state and its proxy's listener counters if needed.
241 * It must be called under the listener's lock, but uses atomic ops to change
242 * the proxy's counters so that the proxy lock is not needed.
243 */
Willy Tarreaua37b2442020-09-24 07:23:45 +0200244void listener_set_state(struct listener *l, enum li_state st)
245{
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200246 struct proxy *px = l->bind_conf->frontend;
247
248 if (px) {
249 /* from state */
250 switch (l->state) {
251 case LI_NEW: /* first call */
Willy Tarreau4781b152021-04-06 13:53:36 +0200252 _HA_ATOMIC_INC(&px->li_all);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200253 break;
254 case LI_INIT:
255 case LI_ASSIGNED:
256 break;
257 case LI_PAUSED:
Willy Tarreau4781b152021-04-06 13:53:36 +0200258 _HA_ATOMIC_DEC(&px->li_paused);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200259 break;
260 case LI_LISTEN:
Willy Tarreau4781b152021-04-06 13:53:36 +0200261 _HA_ATOMIC_DEC(&px->li_bound);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200262 break;
263 case LI_READY:
264 case LI_FULL:
265 case LI_LIMITED:
Willy Tarreau4781b152021-04-06 13:53:36 +0200266 _HA_ATOMIC_DEC(&px->li_ready);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200267 break;
268 }
269
270 /* to state */
271 switch (st) {
272 case LI_NEW:
273 case LI_INIT:
274 case LI_ASSIGNED:
275 break;
276 case LI_PAUSED:
Willy Tarreau95a34602020-10-08 15:32:21 +0200277 BUG_ON(l->rx.fd == -1);
Willy Tarreau4781b152021-04-06 13:53:36 +0200278 _HA_ATOMIC_INC(&px->li_paused);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200279 break;
280 case LI_LISTEN:
Willy Tarreau95a34602020-10-08 15:32:21 +0200281 BUG_ON(l->rx.fd == -1);
Willy Tarreau4781b152021-04-06 13:53:36 +0200282 _HA_ATOMIC_INC(&px->li_bound);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200283 break;
284 case LI_READY:
285 case LI_FULL:
286 case LI_LIMITED:
Willy Tarreau95a34602020-10-08 15:32:21 +0200287 BUG_ON(l->rx.fd == -1);
Willy Tarreau4781b152021-04-06 13:53:36 +0200288 _HA_ATOMIC_INC(&px->li_ready);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200289 break;
290 }
291 }
Willy Tarreaua37b2442020-09-24 07:23:45 +0200292 l->state = st;
293}
294
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100295/* This function adds the specified listener's file descriptor to the polling
296 * lists if it is in the LI_LISTEN state. The listener enters LI_READY or
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500297 * LI_FULL state depending on its number of connections. In daemon mode, we
Willy Tarreauae302532014-05-07 19:22:24 +0200298 * also support binding only the relevant processes to their respective
299 * listeners. We don't do that in debug mode however.
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100300 */
Willy Tarreau7834a3f2020-09-25 16:40:18 +0200301void enable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100302{
Willy Tarreau08b6f962022-02-01 16:23:00 +0100303 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaud6afb532020-10-09 10:35:40 +0200304
305 /* If this listener is supposed to be only in the master, close it in
306 * the workers. Conversely, if it's supposed to be only in the workers
307 * close it in the master.
308 */
Willy Tarreau18c20d22020-10-09 16:11:46 +0200309 if (!!master != !!(listener->rx.flags & RX_F_MWORKER))
Willy Tarreau75c98d12020-10-09 15:55:23 +0200310 do_unbind_listener(listener);
Willy Tarreaud6afb532020-10-09 10:35:40 +0200311
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100312 if (listener->state == LI_LISTEN) {
Willy Tarreau95a34602020-10-08 15:32:21 +0200313 BUG_ON(listener->rx.fd == -1);
William Lallemand095ba4c2017-06-01 17:38:50 +0200314 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau72faef32021-06-15 08:36:30 +0200315 (!!master != !!(listener->rx.flags & RX_F_MWORKER))) {
Willy Tarreauae302532014-05-07 19:22:24 +0200316 /* we don't want to enable this listener and don't
317 * want any fd event to reach it.
318 */
Willy Tarreau75c98d12020-10-09 15:55:23 +0200319 do_unbind_listener(listener);
Willy Tarreauae302532014-05-07 19:22:24 +0200320 }
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100321 else if (!listener->maxconn || listener->nbconn < listener->maxconn) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200322 listener->rx.proto->enable(listener);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200323 listener_set_state(listener, LI_READY);
Willy Tarreauae302532014-05-07 19:22:24 +0200324 }
325 else {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200326 listener_set_state(listener, LI_FULL);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100327 }
328 }
Willy Tarreaud6afb532020-10-09 10:35:40 +0200329
Willy Tarreau08b6f962022-02-01 16:23:00 +0100330 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100331}
332
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200333/*
334 * This function completely stops a listener. It will need to operate under the
335 * proxy's lock, the protocol's lock, and the listener's lock. The caller is
336 * responsible for indicating in lpx, lpr, lli whether the respective locks are
337 * already held (non-zero) or not (zero) so that the function picks the missing
338 * ones, in this order. The proxy's listeners count is updated and the proxy is
339 * disabled and woken up after the last one is gone.
340 */
341void stop_listener(struct listener *l, int lpx, int lpr, int lli)
342{
343 struct proxy *px = l->bind_conf->frontend;
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200344
345 if (l->options & LI_O_NOSTOP) {
346 /* master-worker sockpairs are never closed but don't count as a
347 * job.
348 */
349 return;
350 }
351
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200352 if (!lpx)
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200353 HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200354
355 if (!lpr)
356 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
357
358 if (!lli)
Willy Tarreau08b6f962022-02-01 16:23:00 +0100359 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200360
361 if (l->state > LI_INIT) {
Willy Tarreau75c98d12020-10-09 15:55:23 +0200362 do_unbind_listener(l);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200363
364 if (l->state >= LI_ASSIGNED)
365 __delete_listener(l);
366
Willy Tarreauacde1522020-10-07 16:31:39 +0200367 proxy_cond_disable(px);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200368 }
369
370 if (!lli)
Willy Tarreau08b6f962022-02-01 16:23:00 +0100371 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200372
373 if (!lpr)
374 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
375
376 if (!lpx)
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200377 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &px->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200378}
379
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100380/* This function adds the specified <listener> to the protocol <proto>. It
381 * does nothing if the protocol was already added. The listener's state is
382 * automatically updated from LI_INIT to LI_ASSIGNED. The number of listeners
383 * for the protocol is updated. This must be called with the proto lock held.
384 */
385void default_add_listener(struct protocol *proto, struct listener *listener)
386{
387 if (listener->state != LI_INIT)
388 return;
389 listener_set_state(listener, LI_ASSIGNED);
390 listener->rx.proto = proto;
Willy Tarreau2b718102021-04-21 07:32:39 +0200391 LIST_APPEND(&proto->receivers, &listener->rx.proto_list);
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100392 proto->nb_receivers++;
393}
394
Willy Tarreaue03204c2020-10-09 17:02:21 +0200395/* default function called to suspend a listener: it simply passes the call to
396 * the underlying receiver. This is find for most socket-based protocols. This
397 * must be called under the listener's lock. It will return non-zero on success,
398 * 0 on failure. If no receiver-level suspend is provided, the operation is
399 * assumed to succeed.
400 */
401int default_suspend_listener(struct listener *l)
402{
403 int ret = 1;
404
405 if (!l->rx.proto->rx_suspend)
406 return 1;
407
408 ret = l->rx.proto->rx_suspend(&l->rx);
409 return ret > 0 ? ret : 0;
410}
411
412
413/* Tries to resume a suspended listener, and returns non-zero on success or
414 * zero on failure. On certain errors, an alert or a warning might be displayed.
415 * It must be called with the listener's lock held. Depending on the listener's
416 * state and protocol, a listen() call might be used to resume operations, or a
417 * call to the receiver's resume() function might be used as well. This is
418 * suitable as a default function for TCP and UDP. This must be called with the
419 * listener's lock held.
420 */
421int default_resume_listener(struct listener *l)
422{
423 int ret = 1;
424
425 if (l->state == LI_ASSIGNED) {
426 char msg[100];
427 int err;
428
429 err = l->rx.proto->listen(l, msg, sizeof(msg));
430 if (err & ERR_ALERT)
431 ha_alert("Resuming listener: %s\n", msg);
432 else if (err & ERR_WARN)
433 ha_warning("Resuming listener: %s\n", msg);
434
435 if (err & (ERR_FATAL | ERR_ABORT)) {
436 ret = 0;
437 goto end;
438 }
439 }
440
441 if (l->state < LI_PAUSED) {
442 ret = 0;
443 goto end;
444 }
445
446 if (l->state == LI_PAUSED && l->rx.proto->rx_resume &&
447 l->rx.proto->rx_resume(&l->rx) <= 0)
448 ret = 0;
449 end:
450 return ret;
451}
452
453
Willy Tarreaube58c382011-07-24 18:28:10 +0200454/* This function tries to temporarily disable a listener, depending on the OS
455 * capabilities. Linux unbinds the listen socket after a SHUT_RD, and ignores
456 * SHUT_WR. Solaris refuses either shutdown(). OpenBSD ignores SHUT_RD but
457 * closes upon SHUT_WR and refuses to rebind. So a common validation path
458 * involves SHUT_WR && listen && SHUT_RD. In case of success, the FD's polling
459 * is disabled. It normally returns non-zero, unless an error is reported.
460 */
461int pause_listener(struct listener *l)
462{
Willy Tarreau58651b42020-09-24 16:03:29 +0200463 struct proxy *px = l->bind_conf->frontend;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200464 int ret = 1;
465
Willy Tarreau08b6f962022-02-01 16:23:00 +0100466 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200467
Willy Tarreau9b3a9322020-09-24 14:46:34 +0200468 if (l->state <= LI_PAUSED)
469 goto end;
470
Willy Tarreaue03204c2020-10-09 17:02:21 +0200471 if (l->rx.proto->suspend)
472 ret = l->rx.proto->suspend(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200473
Willy Tarreau2b718102021-04-21 07:32:39 +0200474 MT_LIST_DELETE(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200475
Willy Tarreaua37b2442020-09-24 07:23:45 +0200476 listener_set_state(l, LI_PAUSED);
Willy Tarreau58651b42020-09-24 16:03:29 +0200477
478 if (px && !px->li_ready) {
479 ha_warning("Paused %s %s.\n", proxy_cap_str(px->cap), px->id);
480 send_log(px, LOG_WARNING, "Paused %s %s.\n", proxy_cap_str(px->cap), px->id);
481 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200482 end:
Willy Tarreau08b6f962022-02-01 16:23:00 +0100483 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200484 return ret;
Willy Tarreaube58c382011-07-24 18:28:10 +0200485}
486
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200487/* This function tries to resume a temporarily disabled listener. Paused, full,
488 * limited and disabled listeners are handled, which means that this function
489 * may replace enable_listener(). The resulting state will either be LI_READY
490 * or LI_FULL. 0 is returned in case of failure to resume (eg: dead socket).
Willy Tarreauae302532014-05-07 19:22:24 +0200491 * Listeners bound to a different process are not woken up unless we're in
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200492 * foreground mode, and are ignored. If the listener was only in the assigned
493 * state, it's totally rebound. This can happen if a pause() has completely
494 * stopped it. If the resume fails, 0 is returned and an error might be
495 * displayed.
Willy Tarreaube58c382011-07-24 18:28:10 +0200496 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100497int resume_listener(struct listener *l)
Willy Tarreaube58c382011-07-24 18:28:10 +0200498{
Willy Tarreau58651b42020-09-24 16:03:29 +0200499 struct proxy *px = l->bind_conf->frontend;
500 int was_paused = px && px->li_paused;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200501 int ret = 1;
502
Willy Tarreau08b6f962022-02-01 16:23:00 +0100503 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200504
Willy Tarreauf2cb1692019-07-11 10:08:31 +0200505 /* check that another thread didn't to the job in parallel (e.g. at the
506 * end of listen_accept() while we'd come from dequeue_all_listeners().
507 */
Willy Tarreau2b718102021-04-21 07:32:39 +0200508 if (MT_LIST_INLIST(&l->wait_queue))
Willy Tarreauf2cb1692019-07-11 10:08:31 +0200509 goto end;
510
Willy Tarreau5d7f9ce2020-09-24 18:54:11 +0200511 if (l->state == LI_READY)
512 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200513
Willy Tarreaue03204c2020-10-09 17:02:21 +0200514 if (l->rx.proto->resume)
515 ret = l->rx.proto->resume(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200516
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100517 if (l->maxconn && l->nbconn >= l->maxconn) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200518 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200519 listener_set_state(l, LI_FULL);
Willy Tarreau58651b42020-09-24 16:03:29 +0200520 goto done;
Willy Tarreaube58c382011-07-24 18:28:10 +0200521 }
522
Willy Tarreau4b51f422020-09-25 20:32:28 +0200523 l->rx.proto->enable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200524 listener_set_state(l, LI_READY);
Willy Tarreau58651b42020-09-24 16:03:29 +0200525
526 done:
527 if (was_paused && !px->li_paused) {
528 ha_warning("Resumed %s %s.\n", proxy_cap_str(px->cap), px->id);
529 send_log(px, LOG_WARNING, "Resumed %s %s.\n", proxy_cap_str(px->cap), px->id);
530 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200531 end:
Willy Tarreau08b6f962022-02-01 16:23:00 +0100532 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200533 return ret;
534}
535
Willy Tarreau87b09662015-04-03 00:22:06 +0200536/* Marks a ready listener as full so that the stream code tries to re-enable
Willy Tarreau62793712011-07-24 19:23:38 +0200537 * it upon next close() using resume_listener().
538 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200539static void listener_full(struct listener *l)
Willy Tarreau62793712011-07-24 19:23:38 +0200540{
Willy Tarreau08b6f962022-02-01 16:23:00 +0100541 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200542 if (l->state >= LI_READY) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200543 MT_LIST_DELETE(&l->wait_queue);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100544 if (l->state != LI_FULL) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200545 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200546 listener_set_state(l, LI_FULL);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100547 }
Willy Tarreau62793712011-07-24 19:23:38 +0200548 }
Willy Tarreau08b6f962022-02-01 16:23:00 +0100549 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200550}
551
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200552/* Marks a ready listener as limited so that we only try to re-enable it when
553 * resources are free again. It will be queued into the specified queue.
554 */
Olivier Houchard859dc802019-08-08 15:47:21 +0200555static void limit_listener(struct listener *l, struct mt_list *list)
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200556{
Willy Tarreau08b6f962022-02-01 16:23:00 +0100557 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200558 if (l->state == LI_READY) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200559 MT_LIST_TRY_APPEND(list, &l->wait_queue);
Willy Tarreau4b51f422020-09-25 20:32:28 +0200560 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200561 listener_set_state(l, LI_LIMITED);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200562 }
Willy Tarreau08b6f962022-02-01 16:23:00 +0100563 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200564}
565
Willy Tarreau241797a2019-12-10 14:10:52 +0100566/* Dequeues all listeners waiting for a resource the global wait queue */
567void dequeue_all_listeners()
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200568{
Willy Tarreau01abd022019-02-28 10:27:18 +0100569 struct listener *listener;
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200570
Willy Tarreau241797a2019-12-10 14:10:52 +0100571 while ((listener = MT_LIST_POP(&global_listener_queue, struct listener *, wait_queue))) {
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200572 /* This cannot fail because the listeners are by definition in
Willy Tarreau01abd022019-02-28 10:27:18 +0100573 * the LI_LIMITED state.
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200574 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100575 resume_listener(listener);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200576 }
577}
578
Willy Tarreau241797a2019-12-10 14:10:52 +0100579/* Dequeues all listeners waiting for a resource in proxy <px>'s queue */
580void dequeue_proxy_listeners(struct proxy *px)
581{
582 struct listener *listener;
583
584 while ((listener = MT_LIST_POP(&px->listener_queue, struct listener *, wait_queue))) {
585 /* This cannot fail because the listeners are by definition in
586 * the LI_LIMITED state.
587 */
588 resume_listener(listener);
589 }
590}
591
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200592
593/* default function used to unbind a listener. This is for use by standard
594 * protocols working on top of accepted sockets. The receiver's rx_unbind()
595 * will automatically be used after the listener is disabled if the socket is
596 * still bound. This must be used under the listener's lock.
Christopher Faulet510c0d62018-03-16 10:04:47 +0100597 */
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200598void default_unbind_listener(struct listener *listener)
Willy Tarreaub648d632007-10-28 22:13:50 +0100599{
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200600 if (listener->state <= LI_ASSIGNED)
601 goto out_close;
602
603 if (listener->rx.fd == -1) {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200604 listener_set_state(listener, LI_ASSIGNED);
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200605 goto out_close;
606 }
607
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200608 if (listener->state >= LI_READY) {
609 listener->rx.proto->disable(listener);
610 if (listener->rx.flags & RX_F_BOUND)
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200611 listener_set_state(listener, LI_LISTEN);
Willy Tarreaub6607bf2020-09-23 16:24:23 +0200612 }
613
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200614 out_close:
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200615 if (listener->rx.flags & RX_F_BOUND)
616 listener->rx.proto->rx_unbind(&listener->rx);
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200617}
618
619/* This function closes the listening socket for the specified listener,
620 * provided that it's already in a listening state. The protocol's unbind()
621 * is called to put the listener into LI_ASSIGNED or LI_LISTEN and handle
622 * the unbinding tasks. The listener enters then the LI_ASSIGNED state if
623 * the receiver is unbound. Must be called with the lock held.
624 */
625void do_unbind_listener(struct listener *listener)
626{
Willy Tarreau2b718102021-04-21 07:32:39 +0200627 MT_LIST_DELETE(&listener->wait_queue);
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200628
629 if (listener->rx.proto->unbind)
630 listener->rx.proto->unbind(listener);
Willy Tarreau374e9af2020-10-09 15:47:17 +0200631
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200632 /* we may have to downgrade the listener if the rx was closed */
633 if (!(listener->rx.flags & RX_F_BOUND) && listener->state > LI_ASSIGNED)
Willy Tarreau374e9af2020-10-09 15:47:17 +0200634 listener_set_state(listener, LI_ASSIGNED);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100635}
636
Olivier Houchard1fc05162017-04-06 01:05:05 +0200637/* This function closes the listening socket for the specified listener,
638 * provided that it's already in a listening state. The listener enters the
Willy Tarreau75c98d12020-10-09 15:55:23 +0200639 * LI_ASSIGNED state, except if the FD is not closed, in which case it may
640 * remain in LI_LISTEN. This function is intended to be used as a generic
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100641 * function for standard protocols.
Olivier Houchard1fc05162017-04-06 01:05:05 +0200642 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100643void unbind_listener(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200644{
Willy Tarreau08b6f962022-02-01 16:23:00 +0100645 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau75c98d12020-10-09 15:55:23 +0200646 do_unbind_listener(listener);
Willy Tarreau08b6f962022-02-01 16:23:00 +0100647 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200648}
649
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200650/* creates one or multiple listeners for bind_conf <bc> on sockaddr <ss> on port
651 * range <portl> to <porth>, and possibly attached to fd <fd> (or -1 for auto
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200652 * allocation). The address family is taken from ss->ss_family, and the protocol
Willy Tarreaud2fb99f2020-10-15 21:22:29 +0200653 * passed in <proto> must be usable on this family. The protocol's default iocb
654 * is automatically preset as the receivers' iocb. The number of jobs and
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200655 * listeners is automatically increased by the number of listeners created. It
656 * returns non-zero on success, zero on error with the error message set in <err>.
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200657 */
658int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200659 int portl, int porth, int fd, struct protocol *proto, char **err)
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200660{
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200661 struct listener *l;
662 int port;
663
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200664 for (port = portl; port <= porth; port++) {
665 l = calloc(1, sizeof(*l));
666 if (!l) {
667 memprintf(err, "out of memory");
668 return 0;
669 }
670 l->obj_type = OBJ_TYPE_LISTENER;
Willy Tarreau2b718102021-04-21 07:32:39 +0200671 LIST_APPEND(&bc->frontend->conf.listeners, &l->by_fe);
672 LIST_APPEND(&bc->listeners, &l->by_bind);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200673 l->bind_conf = bc;
Willy Tarreau0fce6bc2020-09-03 07:46:06 +0200674 l->rx.settings = &bc->settings;
Willy Tarreaueef45422020-09-03 10:05:03 +0200675 l->rx.owner = l;
Willy Tarreaud2fb99f2020-10-15 21:22:29 +0200676 l->rx.iocb = proto->default_iocb;
Willy Tarreau38ba6472020-08-27 08:16:52 +0200677 l->rx.fd = fd;
Willy Tarreau07400c52020-12-04 14:49:11 +0100678
Willy Tarreau37159062020-08-27 07:48:42 +0200679 memcpy(&l->rx.addr, ss, sizeof(*ss));
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100680 if (proto->fam->set_port)
681 proto->fam->set_port(&l->rx.addr, port);
Willy Tarreau07400c52020-12-04 14:49:11 +0100682
Olivier Houchard859dc802019-08-08 15:47:21 +0200683 MT_LIST_INIT(&l->wait_queue);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200684 listener_set_state(l, LI_INIT);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200685
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100686 proto->add(proto, l);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200687
Willy Tarreau909c23b2020-09-15 13:50:58 +0200688 if (fd != -1)
Willy Tarreau43046fa2020-09-01 15:41:59 +0200689 l->rx.flags |= RX_F_INHERITED;
William Lallemand75ea0a02017-11-15 19:02:58 +0100690
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +0100691 l->extra_counters = NULL;
692
Willy Tarreau08b6f962022-02-01 16:23:00 +0100693 HA_RWLOCK_INIT(&l->lock);
Willy Tarreau4781b152021-04-06 13:53:36 +0200694 _HA_ATOMIC_INC(&jobs);
695 _HA_ATOMIC_INC(&listeners);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200696 }
697 return 1;
698}
699
Willy Tarreau59a877d2021-10-12 09:36:10 +0200700/* clones listener <src> and returns the new one. All dynamically allocated
701 * fields are reallocated (name for now). The new listener is inserted before
702 * the original one in the bind_conf and frontend lists. This allows it to be
703 * duplicated while iterating over the current list. The original listener must
704 * only be in the INIT or ASSIGNED states, and the new listener will only be
705 * placed into the INIT state. The counters are always set to NULL. Maxsock is
706 * updated. Returns NULL on allocation error.
707 */
708struct listener *clone_listener(struct listener *src)
709{
710 struct listener *l;
711
712 l = calloc(1, sizeof(*l));
713 if (!l)
714 goto oom1;
715 memcpy(l, src, sizeof(*l));
716
717 if (l->name) {
718 l->name = strdup(l->name);
719 if (!l->name)
720 goto oom2;
721 }
722
723 l->rx.owner = l;
724 l->state = LI_INIT;
725 l->counters = NULL;
726 l->extra_counters = NULL;
727
728 LIST_APPEND(&src->by_fe, &l->by_fe);
729 LIST_APPEND(&src->by_bind, &l->by_bind);
730
731 MT_LIST_INIT(&l->wait_queue);
732
733 l->rx.proto->add(l->rx.proto, l);
734
Willy Tarreau08b6f962022-02-01 16:23:00 +0100735 HA_RWLOCK_INIT(&l->lock);
Willy Tarreau59a877d2021-10-12 09:36:10 +0200736 _HA_ATOMIC_INC(&jobs);
737 _HA_ATOMIC_INC(&listeners);
738 global.maxsock++;
739 return l;
740
Willy Tarreau59a877d2021-10-12 09:36:10 +0200741 oom2:
742 free(l);
743 oom1:
Willy Tarreaua1462892021-10-16 14:45:29 +0200744 return NULL;
Willy Tarreau59a877d2021-10-12 09:36:10 +0200745}
746
Willy Tarreau1a64d162007-10-28 22:26:05 +0100747/* Delete a listener from its protocol's list of listeners. The listener's
748 * state is automatically updated from LI_ASSIGNED to LI_INIT. The protocol's
Willy Tarreau2cc5bae2017-09-15 08:18:11 +0200749 * number of listeners is updated, as well as the global number of listeners
750 * and jobs. Note that the listener must have previously been unbound. This
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200751 * is a low-level function expected to be called with the proto_lock and the
752 * listener's lock held.
Willy Tarreau1a64d162007-10-28 22:26:05 +0100753 */
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200754void __delete_listener(struct listener *listener)
Willy Tarreau1a64d162007-10-28 22:26:05 +0100755{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100756 if (listener->state == LI_ASSIGNED) {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200757 listener_set_state(listener, LI_INIT);
Willy Tarreau2b718102021-04-21 07:32:39 +0200758 LIST_DELETE(&listener->rx.proto_list);
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200759 listener->rx.proto->nb_receivers--;
Willy Tarreau4781b152021-04-06 13:53:36 +0200760 _HA_ATOMIC_DEC(&jobs);
761 _HA_ATOMIC_DEC(&listeners);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100762 }
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200763}
764
765/* Delete a listener from its protocol's list of listeners (please check
766 * __delete_listener() above). The proto_lock and the listener's lock will
767 * be grabbed in this order.
768 */
769void delete_listener(struct listener *listener)
770{
771 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau08b6f962022-02-01 16:23:00 +0100772 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200773 __delete_listener(listener);
Willy Tarreau08b6f962022-02-01 16:23:00 +0100774 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau6ee9f8d2019-08-26 10:55:52 +0200775 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau1a64d162007-10-28 22:26:05 +0100776}
777
Willy Tarreaue2711c72019-02-27 15:39:41 +0100778/* Returns a suitable value for a listener's backlog. It uses the listener's,
779 * otherwise the frontend's backlog, otherwise the listener's maxconn,
780 * otherwise the frontend's maxconn, otherwise 1024.
781 */
782int listener_backlog(const struct listener *l)
783{
784 if (l->backlog)
785 return l->backlog;
786
787 if (l->bind_conf->frontend->backlog)
788 return l->bind_conf->frontend->backlog;
789
790 if (l->maxconn)
791 return l->maxconn;
792
793 if (l->bind_conf->frontend->maxconn)
794 return l->bind_conf->frontend->maxconn;
795
796 return 1024;
797}
798
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200799/* This function is called on a read event from a listening socket, corresponding
800 * to an accept. It tries to accept as many connections as possible, and for each
801 * calls the listener's accept handler (generally the frontend's accept handler).
802 */
Willy Tarreaua74cb382020-10-15 21:29:49 +0200803void listener_accept(struct listener *l)
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200804{
Willy Tarreau83efc322020-10-14 17:37:17 +0200805 struct connection *cli_conn;
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100806 struct proxy *p;
Christopher Faulet102854c2019-04-30 12:17:13 +0200807 unsigned int max_accept;
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100808 int next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100809 int next_feconn = 0;
810 int next_actconn = 0;
Willy Tarreaubb660302014-05-07 19:47:02 +0200811 int expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200812 int ret;
813
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100814 p = l->bind_conf->frontend;
Christopher Faulet102854c2019-04-30 12:17:13 +0200815
816 /* if l->maxaccept is -1, then max_accept is UINT_MAX. It is not really
817 * illimited, but it is probably enough.
818 */
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100819 max_accept = l->maxaccept ? l->maxaccept : 1;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200820
Willy Tarreau93e7c002013-10-07 18:51:07 +0200821 if (!(l->options & LI_O_UNLIMITED) && global.sps_lim) {
822 int max = freq_ctr_remain(&global.sess_per_sec, global.sps_lim, 0);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200823
824 if (unlikely(!max)) {
825 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200826 expire = tick_add(now_ms, next_event_delay(&global.sess_per_sec, global.sps_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100827 goto limit_global;
Willy Tarreau93e7c002013-10-07 18:51:07 +0200828 }
829
830 if (max_accept > max)
831 max_accept = max;
832 }
833
834 if (!(l->options & LI_O_UNLIMITED) && global.cps_lim) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200835 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
836
837 if (unlikely(!max)) {
838 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200839 expire = tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100840 goto limit_global;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200841 }
842
843 if (max_accept > max)
844 max_accept = max;
845 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200846#ifdef USE_OPENSSL
Willy Tarreau11ba4042022-05-20 15:56:32 +0200847 if (!(l->options & LI_O_UNLIMITED) && global.ssl_lim &&
848 l->bind_conf && l->bind_conf->options & BC_O_USE_SSL) {
Willy Tarreaue43d5322013-10-07 20:01:52 +0200849 int max = freq_ctr_remain(&global.ssl_per_sec, global.ssl_lim, 0);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200850
Willy Tarreaue43d5322013-10-07 20:01:52 +0200851 if (unlikely(!max)) {
852 /* frontend accept rate limit was reached */
Willy Tarreaue43d5322013-10-07 20:01:52 +0200853 expire = tick_add(now_ms, next_event_delay(&global.ssl_per_sec, global.ssl_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100854 goto limit_global;
Willy Tarreaue43d5322013-10-07 20:01:52 +0200855 }
856
857 if (max_accept > max)
858 max_accept = max;
859 }
860#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200861 if (p && p->fe_sps_lim) {
862 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
863
864 if (unlikely(!max)) {
865 /* frontend accept rate limit was reached */
Willy Tarreau0591bf72019-12-10 12:01:21 +0100866 expire = tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0));
867 goto limit_proxy;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200868 }
869
870 if (max_accept > max)
871 max_accept = max;
872 }
873
874 /* Note: if we fail to allocate a connection because of configured
875 * limits, we'll schedule a new attempt worst 1 second later in the
876 * worst case. If we fail due to system limits or temporary resource
877 * shortage, we try again 100ms later in the worst case.
878 */
Willy Tarreau02757d02021-01-28 18:07:24 +0100879 for (; max_accept; next_conn = next_feconn = next_actconn = 0, max_accept--) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200880 unsigned int count;
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200881 int status;
Willy Tarreau0aa5a5b2020-10-16 17:43:04 +0200882 __decl_thread(unsigned long mask);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200883
Willy Tarreau82c97892019-02-27 19:32:32 +0100884 /* pre-increase the number of connections without going too far.
885 * We process the listener, then the proxy, then the process.
886 * We know which ones to unroll based on the next_xxx value.
887 */
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100888 do {
889 count = l->nbconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100890 if (unlikely(l->maxconn && count >= l->maxconn)) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100891 /* the listener was marked full or another
892 * thread is going to do it.
893 */
894 next_conn = 0;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100895 listener_full(l);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100896 goto end;
897 }
898 next_conn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000899 } while (!_HA_ATOMIC_CAS(&l->nbconn, (int *)(&count), next_conn));
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100900
Willy Tarreau82c97892019-02-27 19:32:32 +0100901 if (p) {
902 do {
903 count = p->feconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100904 if (unlikely(count >= p->maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100905 /* the frontend was marked full or another
906 * thread is going to do it.
907 */
908 next_feconn = 0;
Willy Tarreau0591bf72019-12-10 12:01:21 +0100909 expire = TICK_ETERNITY;
910 goto limit_proxy;
Willy Tarreau82c97892019-02-27 19:32:32 +0100911 }
912 next_feconn = count + 1;
Olivier Houchard64213e92019-03-08 18:52:57 +0100913 } while (!_HA_ATOMIC_CAS(&p->feconn, &count, next_feconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200914 }
915
Willy Tarreau82c97892019-02-27 19:32:32 +0100916 if (!(l->options & LI_O_UNLIMITED)) {
917 do {
918 count = actconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100919 if (unlikely(count >= global.maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100920 /* the process was marked full or another
921 * thread is going to do it.
922 */
923 next_actconn = 0;
Willy Tarreau0591bf72019-12-10 12:01:21 +0100924 expire = tick_add(now_ms, 1000); /* try again in 1 second */
925 goto limit_global;
Willy Tarreau82c97892019-02-27 19:32:32 +0100926 }
927 next_actconn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000928 } while (!_HA_ATOMIC_CAS(&actconn, (int *)(&count), next_actconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200929 }
930
Willy Tarreaufed93d32022-02-01 16:37:00 +0100931 /* be careful below, the listener might be shutting down in
932 * another thread on error and we must not dereference its
933 * FD without a bit of protection.
934 */
935 cli_conn = NULL;
936 status = CO_AC_PERMERR;
937
938 HA_RWLOCK_RDLOCK(LISTENER_LOCK, &l->lock);
939 if (l->rx.flags & RX_F_BOUND)
940 cli_conn = l->rx.proto->accept_conn(l, &status);
941 HA_RWLOCK_RDUNLOCK(LISTENER_LOCK, &l->lock);
942
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200943 if (!cli_conn) {
944 switch (status) {
945 case CO_AC_DONE:
946 goto end;
Willy Tarreau818dca52014-01-31 19:40:19 +0100947
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200948 case CO_AC_RETRY: /* likely a signal */
Willy Tarreau4781b152021-04-06 13:53:36 +0200949 _HA_ATOMIC_DEC(&l->nbconn);
Willy Tarreau82c97892019-02-27 19:32:32 +0100950 if (p)
Willy Tarreau4781b152021-04-06 13:53:36 +0200951 _HA_ATOMIC_DEC(&p->feconn);
Willy Tarreau82c97892019-02-27 19:32:32 +0100952 if (!(l->options & LI_O_UNLIMITED))
Willy Tarreau4781b152021-04-06 13:53:36 +0200953 _HA_ATOMIC_DEC(&actconn);
Willy Tarreaua593ec52014-01-20 21:21:30 +0100954 continue;
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200955
956 case CO_AC_YIELD:
Willy Tarreau92079932019-12-10 09:30:05 +0100957 max_accept = 0;
958 goto end;
William Lallemandd9138002018-11-27 12:02:39 +0100959
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200960 default:
961 goto transient_error;
Willy Tarreau83efc322020-10-14 17:37:17 +0200962 }
963 }
964
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100965 /* The connection was accepted, it must be counted as such */
966 if (l->counters)
967 HA_ATOMIC_UPDATE_MAX(&l->counters->conn_max, next_conn);
968
Willy Tarreaud8679342022-05-09 20:41:54 +0200969 if (p) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100970 HA_ATOMIC_UPDATE_MAX(&p->fe_counters.conn_max, next_feconn);
Willy Tarreaud8679342022-05-09 20:41:54 +0200971 proxy_inc_fe_conn_ctr(l, p);
972 }
Willy Tarreau82c97892019-02-27 19:32:32 +0100973
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100974 if (!(l->options & LI_O_UNLIMITED)) {
975 count = update_freq_ctr(&global.conn_per_sec, 1);
976 HA_ATOMIC_UPDATE_MAX(&global.cps_max, count);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100977 }
978
Willy Tarreau4781b152021-04-06 13:53:36 +0200979 _HA_ATOMIC_INC(&activity[tid].accepted);
Willy Tarreau64a9c052019-04-12 15:27:17 +0200980
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100981 /* past this point, l->accept() will automatically decrement
Willy Tarreau82c97892019-02-27 19:32:32 +0100982 * l->nbconn, feconn and actconn once done. Setting next_*conn=0
983 * allows the error path not to rollback on nbconn. It's more
984 * convenient than duplicating all exit labels.
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100985 */
986 next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100987 next_feconn = 0;
988 next_actconn = 0;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200989
Willy Tarreau83efc322020-10-14 17:37:17 +0200990
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100991#if defined(USE_THREAD)
Amaury Denoyelle7f7713d2022-01-19 11:37:50 +0100992 if (l->rx.flags & RX_F_LOCAL_ACCEPT)
993 goto local_accept;
994
Willy Tarreau01cac3f2021-10-12 08:47:54 +0200995 mask = thread_mask(l->rx.bind_thread) & all_threads_mask;
Willy Tarreaua7da5e82020-03-12 17:33:29 +0100996 if (atleast2(mask) && (global.tune.options & GTUNE_LISTENER_MQ) && !stopping) {
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100997 struct accept_queue_ring *ring;
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100998 unsigned int t, t0, t1, t2;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100999
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001000 /* The principle is that we have two running indexes,
1001 * each visiting in turn all threads bound to this
1002 * listener. The connection will be assigned to the one
1003 * with the least connections, and the other one will
1004 * be updated. This provides a good fairness on short
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001005 * connections (round robin) and on long ones (conn
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001006 * count), without ever missing any idle thread.
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001007 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001008
1009 /* keep a copy for the final update. thr_idx is composite
1010 * and made of (t2<<16) + t1.
1011 */
Willy Tarreau0cf33172019-03-06 15:26:33 +01001012 t0 = l->thr_idx;
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001013 do {
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001014 unsigned long m1, m2;
1015 int q1, q2;
1016
1017 t2 = t1 = t0;
1018 t2 >>= 16;
1019 t1 &= 0xFFFF;
1020
1021 /* t1 walks low to high bits ;
1022 * t2 walks high to low.
1023 */
1024 m1 = mask >> t1;
1025 m2 = mask & (t2 ? nbits(t2 + 1) : ~0UL);
1026
Willy Tarreau85d04242019-04-16 18:09:13 +02001027 if (unlikely(!(m1 & 1))) {
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001028 m1 &= ~1UL;
1029 if (!m1) {
1030 m1 = mask;
1031 t1 = 0;
1032 }
1033 t1 += my_ffsl(m1) - 1;
1034 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001035
Willy Tarreau85d04242019-04-16 18:09:13 +02001036 if (unlikely(!(m2 & (1UL << t2)) || t1 == t2)) {
1037 /* highest bit not set */
1038 if (!m2)
1039 m2 = mask;
1040
1041 t2 = my_flsl(m2) - 1;
1042 }
1043
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001044 /* now we have two distinct thread IDs belonging to the mask */
1045 q1 = accept_queue_rings[t1].tail - accept_queue_rings[t1].head + ACCEPT_QUEUE_SIZE;
1046 if (q1 >= ACCEPT_QUEUE_SIZE)
1047 q1 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001048
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001049 q2 = accept_queue_rings[t2].tail - accept_queue_rings[t2].head + ACCEPT_QUEUE_SIZE;
1050 if (q2 >= ACCEPT_QUEUE_SIZE)
1051 q2 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001052
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001053 /* we have 3 possibilities now :
1054 * q1 < q2 : t1 is less loaded than t2, so we pick it
1055 * and update t2 (since t1 might still be
1056 * lower than another thread)
1057 * q1 > q2 : t2 is less loaded than t1, so we pick it
1058 * and update t1 (since t2 might still be
1059 * lower than another thread)
1060 * q1 = q2 : both are equally loaded, thus we pick t1
1061 * and update t1 as it will become more loaded
1062 * than t2.
1063 */
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001064
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001065 q1 += l->thr_conn[t1];
1066 q2 += l->thr_conn[t2];
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001067
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001068 if (q1 - q2 < 0) {
1069 t = t1;
1070 t2 = t2 ? t2 - 1 : LONGBITS - 1;
1071 }
1072 else if (q1 - q2 > 0) {
1073 t = t2;
1074 t1++;
1075 if (t1 >= LONGBITS)
1076 t1 = 0;
1077 }
1078 else {
1079 t = t1;
1080 t1++;
1081 if (t1 >= LONGBITS)
1082 t1 = 0;
1083 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001084
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001085 /* new value for thr_idx */
1086 t1 += (t2 << 16);
Olivier Houchard64213e92019-03-08 18:52:57 +01001087 } while (unlikely(!_HA_ATOMIC_CAS(&l->thr_idx, &t0, t1)));
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001088
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001089 /* We successfully selected the best thread "t" for this
1090 * connection. We use deferred accepts even if it's the
1091 * local thread because tests show that it's the best
1092 * performing model, likely due to better cache locality
1093 * when processing this loop.
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001094 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001095 ring = &accept_queue_rings[t];
Willy Tarreau83efc322020-10-14 17:37:17 +02001096 if (accept_queue_push_mp(ring, cli_conn)) {
Willy Tarreau4781b152021-04-06 13:53:36 +02001097 _HA_ATOMIC_INC(&activity[t].accq_pushed);
Willy Tarreau2bd65a72019-09-24 06:55:18 +02001098 tasklet_wakeup(ring->tasklet);
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001099 continue;
1100 }
1101 /* If the ring is full we do a synchronous accept on
1102 * the local thread here.
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001103 */
Willy Tarreau4781b152021-04-06 13:53:36 +02001104 _HA_ATOMIC_INC(&activity[t].accq_full);
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001105 }
1106#endif // USE_THREAD
1107
Amaury Denoyelle7f7713d2022-01-19 11:37:50 +01001108 local_accept:
Willy Tarreau4781b152021-04-06 13:53:36 +02001109 _HA_ATOMIC_INC(&l->thr_conn[tid]);
Willy Tarreau83efc322020-10-14 17:37:17 +02001110 ret = l->accept(cli_conn);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001111 if (unlikely(ret <= 0)) {
Willy Tarreau87b09662015-04-03 00:22:06 +02001112 /* The connection was closed by stream_accept(). Either
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001113 * we just have to ignore it (ret == 0) or it's a critical
1114 * error due to a resource shortage, and we must stop the
1115 * listener (ret < 0).
1116 */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001117 if (ret == 0) /* successful termination */
1118 continue;
1119
Willy Tarreaubb660302014-05-07 19:47:02 +02001120 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001121 }
1122
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001123 /* increase the per-process number of cumulated sessions, this
1124 * may only be done once l->accept() has accepted the connection.
1125 */
Willy Tarreau93e7c002013-10-07 18:51:07 +02001126 if (!(l->options & LI_O_UNLIMITED)) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001127 count = update_freq_ctr(&global.sess_per_sec, 1);
1128 HA_ATOMIC_UPDATE_MAX(&global.sps_max, count);
Willy Tarreau93e7c002013-10-07 18:51:07 +02001129 }
Willy Tarreaue43d5322013-10-07 20:01:52 +02001130#ifdef USE_OPENSSL
Willy Tarreau11ba4042022-05-20 15:56:32 +02001131 if (!(l->options & LI_O_UNLIMITED) &&
1132 l->bind_conf && l->bind_conf->options & BC_O_USE_SSL) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001133 count = update_freq_ctr(&global.ssl_per_sec, 1);
1134 HA_ATOMIC_UPDATE_MAX(&global.ssl_max, count);
Willy Tarreaue43d5322013-10-07 20:01:52 +02001135 }
1136#endif
Willy Tarreau93e7c002013-10-07 18:51:07 +02001137
Willy Tarreaua0b99532021-09-30 18:48:37 +02001138 th_ctx->flags &= ~TH_FL_STUCK; // this thread is still running
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001139 } /* end of for (max_accept--) */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001140
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001141 end:
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001142 if (next_conn)
Willy Tarreau4781b152021-04-06 13:53:36 +02001143 _HA_ATOMIC_DEC(&l->nbconn);
Willy Tarreau741b4d62019-02-25 15:02:04 +01001144
Willy Tarreau82c97892019-02-27 19:32:32 +01001145 if (p && next_feconn)
Willy Tarreau4781b152021-04-06 13:53:36 +02001146 _HA_ATOMIC_DEC(&p->feconn);
Willy Tarreau82c97892019-02-27 19:32:32 +01001147
1148 if (next_actconn)
Willy Tarreau4781b152021-04-06 13:53:36 +02001149 _HA_ATOMIC_DEC(&actconn);
Willy Tarreau82c97892019-02-27 19:32:32 +01001150
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001151 if ((l->state == LI_FULL && (!l->maxconn || l->nbconn < l->maxconn)) ||
Willy Tarreau02757d02021-01-28 18:07:24 +01001152 (l->state == LI_LIMITED &&
Willy Tarreaucdcba112019-12-11 15:06:30 +01001153 ((!p || p->feconn < p->maxconn) && (actconn < global.maxconn) &&
1154 (!tick_isset(global_listener_queue_task->expire) ||
1155 tick_is_expired(global_listener_queue_task->expire, now_ms))))) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001156 /* at least one thread has to this when quitting */
1157 resume_listener(l);
1158
Willy Tarreau02757d02021-01-28 18:07:24 +01001159 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001160 dequeue_all_listeners();
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001161
Olivier Houchard859dc802019-08-08 15:47:21 +02001162 if (p && !MT_LIST_ISEMPTY(&p->listener_queue) &&
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001163 (!p->fe_sps_lim || freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0) > 0))
Willy Tarreau241797a2019-12-10 14:10:52 +01001164 dequeue_proxy_listeners(p);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001165 }
Willy Tarreau0591bf72019-12-10 12:01:21 +01001166 return;
1167
1168 transient_error:
1169 /* pause the listener for up to 100 ms */
1170 expire = tick_add(now_ms, 100);
1171
Willy Tarreau258b3512020-10-13 17:46:05 +02001172 /* This may be a shared socket that was paused by another process.
1173 * Let's put it to pause in this case.
1174 */
1175 if (l->rx.proto && l->rx.proto->rx_listening(&l->rx) == 0) {
1176 pause_listener(l);
1177 goto end;
1178 }
1179
Willy Tarreau0591bf72019-12-10 12:01:21 +01001180 limit_global:
1181 /* (re-)queue the listener to the global queue and set it to expire no
1182 * later than <expire> ahead. The listener turns to LI_LIMITED.
1183 */
1184 limit_listener(l, &global_listener_queue);
1185 task_schedule(global_listener_queue_task, expire);
1186 goto end;
1187
1188 limit_proxy:
1189 /* (re-)queue the listener to the proxy's queue and set it to expire no
1190 * later than <expire> ahead. The listener turns to LI_LIMITED.
1191 */
1192 limit_listener(l, &p->listener_queue);
Willy Tarreaueeea8082020-01-08 19:15:07 +01001193 if (p->task && tick_isset(expire))
1194 task_schedule(p->task, expire);
Willy Tarreau0591bf72019-12-10 12:01:21 +01001195 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001196}
1197
Willy Tarreau05f50472017-09-15 09:19:58 +02001198/* Notify the listener that a connection initiated from it was released. This
1199 * is used to keep the connection count consistent and to possibly re-open
1200 * listening when it was limited.
1201 */
1202void listener_release(struct listener *l)
1203{
1204 struct proxy *fe = l->bind_conf->frontend;
1205
1206 if (!(l->options & LI_O_UNLIMITED))
Willy Tarreau4781b152021-04-06 13:53:36 +02001207 _HA_ATOMIC_DEC(&actconn);
Willy Tarreau82c97892019-02-27 19:32:32 +01001208 if (fe)
Willy Tarreau4781b152021-04-06 13:53:36 +02001209 _HA_ATOMIC_DEC(&fe->feconn);
1210 _HA_ATOMIC_DEC(&l->nbconn);
1211 _HA_ATOMIC_DEC(&l->thr_conn[tid]);
Willy Tarreau82c97892019-02-27 19:32:32 +01001212
1213 if (l->state == LI_FULL || l->state == LI_LIMITED)
Willy Tarreau05f50472017-09-15 09:19:58 +02001214 resume_listener(l);
1215
Willy Tarreau02757d02021-01-28 18:07:24 +01001216 /* Dequeues all of the listeners waiting for a resource */
1217 dequeue_all_listeners();
1218
Olivier Houchard859dc802019-08-08 15:47:21 +02001219 if (!MT_LIST_ISEMPTY(&fe->listener_queue) &&
Willy Tarreau05f50472017-09-15 09:19:58 +02001220 (!fe->fe_sps_lim || freq_ctr_remain(&fe->fe_sess_per_sec, fe->fe_sps_lim, 0) > 0))
Willy Tarreau241797a2019-12-10 14:10:52 +01001221 dequeue_proxy_listeners(fe);
Willy Tarreau05f50472017-09-15 09:19:58 +02001222}
1223
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001224/* Initializes the listener queues. Returns 0 on success, otherwise ERR_* flags */
1225static int listener_queue_init()
1226{
Willy Tarreaubeeabf52021-10-01 18:23:30 +02001227 global_listener_queue_task = task_new_anywhere();
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001228 if (!global_listener_queue_task) {
1229 ha_alert("Out of memory when initializing global listener queue\n");
1230 return ERR_FATAL|ERR_ABORT;
1231 }
1232 /* very simple initialization, users will queue the task if needed */
1233 global_listener_queue_task->context = NULL; /* not even a context! */
1234 global_listener_queue_task->process = manage_global_listener_queue;
1235
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001236 return 0;
1237}
1238
1239static void listener_queue_deinit()
1240{
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001241 task_destroy(global_listener_queue_task);
1242 global_listener_queue_task = NULL;
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001243}
1244
1245REGISTER_CONFIG_POSTPARSER("multi-threaded listener queue", listener_queue_init);
1246REGISTER_POST_DEINIT(listener_queue_deinit);
1247
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001248
1249/* This is the global management task for listeners. It enables listeners waiting
1250 * for global resources when there are enough free resource, or at least once in
Willy Tarreaud597ec22021-01-29 14:29:06 +01001251 * a while. It is designed to be called as a task. It's exported so that it's easy
1252 * to spot in "show tasks" or "show profiling".
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001253 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001254struct task *manage_global_listener_queue(struct task *t, void *context, unsigned int state)
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001255{
1256 /* If there are still too many concurrent connections, let's wait for
1257 * some of them to go away. We don't need to re-arm the timer because
1258 * each of them will scan the queue anyway.
1259 */
1260 if (unlikely(actconn >= global.maxconn))
1261 goto out;
1262
1263 /* We should periodically try to enable listeners waiting for a global
1264 * resource here, because it is possible, though very unlikely, that
1265 * they have been blocked by a temporary lack of global resource such
1266 * as a file descriptor or memory and that the temporary condition has
1267 * disappeared.
1268 */
1269 dequeue_all_listeners();
1270
1271 out:
1272 t->expire = TICK_ETERNITY;
1273 task_queue(t);
1274 return t;
1275}
1276
Willy Tarreau26982662012-09-12 23:17:10 +02001277/*
1278 * Registers the bind keyword list <kwl> as a list of valid keywords for next
1279 * parsing sessions.
1280 */
1281void bind_register_keywords(struct bind_kw_list *kwl)
1282{
Willy Tarreau2b718102021-04-21 07:32:39 +02001283 LIST_APPEND(&bind_keywords.list, &kwl->list);
Willy Tarreau26982662012-09-12 23:17:10 +02001284}
1285
1286/* Return a pointer to the bind keyword <kw>, or NULL if not found. If the
1287 * keyword is found with a NULL ->parse() function, then an attempt is made to
1288 * find one with a valid ->parse() function. This way it is possible to declare
1289 * platform-dependant, known keywords as NULL, then only declare them as valid
1290 * if some options are met. Note that if the requested keyword contains an
1291 * opening parenthesis, everything from this point is ignored.
1292 */
1293struct bind_kw *bind_find_kw(const char *kw)
1294{
1295 int index;
1296 const char *kwend;
1297 struct bind_kw_list *kwl;
1298 struct bind_kw *ret = NULL;
1299
1300 kwend = strchr(kw, '(');
1301 if (!kwend)
1302 kwend = kw + strlen(kw);
1303
1304 list_for_each_entry(kwl, &bind_keywords.list, list) {
1305 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1306 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
1307 kwl->kw[index].kw[kwend-kw] == 0) {
1308 if (kwl->kw[index].parse)
1309 return &kwl->kw[index]; /* found it !*/
1310 else
1311 ret = &kwl->kw[index]; /* may be OK */
1312 }
1313 }
1314 }
1315 return ret;
1316}
1317
Willy Tarreau8638f482012-09-18 18:01:17 +02001318/* Dumps all registered "bind" keywords to the <out> string pointer. The
1319 * unsupported keywords are only dumped if their supported form was not
1320 * found.
1321 */
1322void bind_dump_kws(char **out)
1323{
1324 struct bind_kw_list *kwl;
1325 int index;
1326
Christopher Faulet784063e2020-05-18 12:14:18 +02001327 if (!out)
1328 return;
1329
Willy Tarreau8638f482012-09-18 18:01:17 +02001330 *out = NULL;
1331 list_for_each_entry(kwl, &bind_keywords.list, list) {
1332 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1333 if (kwl->kw[index].parse ||
1334 bind_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
Willy Tarreau51fb7652012-09-18 18:24:39 +02001335 memprintf(out, "%s[%4s] %s%s%s\n", *out ? *out : "",
1336 kwl->scope,
Willy Tarreau8638f482012-09-18 18:01:17 +02001337 kwl->kw[index].kw,
Willy Tarreau51fb7652012-09-18 18:24:39 +02001338 kwl->kw[index].skip ? " <arg>" : "",
1339 kwl->kw[index].parse ? "" : " (not supported)");
Willy Tarreau8638f482012-09-18 18:01:17 +02001340 }
1341 }
1342 }
1343}
1344
Willy Tarreau433b05f2021-03-12 10:14:07 +01001345/* Try to find in srv_keyword the word that looks closest to <word> by counting
1346 * transitions between letters, digits and other characters. Will return the
1347 * best matching word if found, otherwise NULL.
1348 */
1349const char *bind_find_best_kw(const char *word)
1350{
1351 uint8_t word_sig[1024];
1352 uint8_t list_sig[1024];
1353 const struct bind_kw_list *kwl;
1354 const char *best_ptr = NULL;
1355 int dist, best_dist = INT_MAX;
1356 int index;
1357
1358 make_word_fingerprint(word_sig, word);
1359 list_for_each_entry(kwl, &bind_keywords.list, list) {
1360 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1361 make_word_fingerprint(list_sig, kwl->kw[index].kw);
1362 dist = word_fingerprint_distance(word_sig, list_sig);
1363 if (dist < best_dist) {
1364 best_dist = dist;
1365 best_ptr = kwl->kw[index].kw;
1366 }
1367 }
1368 }
1369
1370 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
1371 best_ptr = NULL;
1372
1373 return best_ptr;
1374}
1375
Willy Tarreaudbf78022021-10-06 09:05:08 +02001376/* allocate an bind_conf struct for a bind line, and chain it to the frontend <fe>.
1377 * If <arg> is not NULL, it is duplicated into ->arg to store useful config
1378 * information for error reporting. NULL is returned on error.
1379 */
1380struct bind_conf *bind_conf_alloc(struct proxy *fe, const char *file,
1381 int line, const char *arg, struct xprt_ops *xprt)
1382{
1383 struct bind_conf *bind_conf = calloc(1, sizeof(*bind_conf));
1384
1385 if (!bind_conf)
1386 goto err;
1387
1388 bind_conf->file = strdup(file);
1389 if (!bind_conf->file)
1390 goto err;
1391 bind_conf->line = line;
1392 if (arg) {
1393 bind_conf->arg = strdup(arg);
1394 if (!bind_conf->arg)
1395 goto err;
1396 }
1397
1398 LIST_APPEND(&fe->conf.bind, &bind_conf->by_fe);
1399 bind_conf->settings.ux.uid = -1;
1400 bind_conf->settings.ux.gid = -1;
1401 bind_conf->settings.ux.mode = 0;
Willy Tarreau6dfbef42021-10-12 15:23:03 +02001402 bind_conf->settings.shards = 1;
Willy Tarreaudbf78022021-10-06 09:05:08 +02001403 bind_conf->xprt = xprt;
1404 bind_conf->frontend = fe;
1405 bind_conf->severity_output = CLI_SEVERITY_NONE;
1406#ifdef USE_OPENSSL
1407 HA_RWLOCK_INIT(&bind_conf->sni_lock);
1408 bind_conf->sni_ctx = EB_ROOT;
1409 bind_conf->sni_w_ctx = EB_ROOT;
1410#endif
1411 LIST_INIT(&bind_conf->listeners);
1412 return bind_conf;
1413
1414 err:
1415 if (bind_conf) {
1416 ha_free(&bind_conf->file);
1417 ha_free(&bind_conf->arg);
1418 }
1419 ha_free(&bind_conf);
1420 return NULL;
1421}
1422
1423const char *listener_state_str(const struct listener *l)
1424{
1425 static const char *states[8] = {
1426 "NEW", "INI", "ASS", "PAU", "LIS", "RDY", "FUL", "LIM",
1427 };
1428 unsigned int st = l->state;
1429
1430 if (st >= sizeof(states) / sizeof(*states))
1431 return "INVALID";
1432 return states[st];
1433}
1434
Willy Tarreau645513a2010-05-24 20:55:15 +02001435/************************************************************************/
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001436/* All supported sample and ACL keywords must be declared here. */
Willy Tarreau645513a2010-05-24 20:55:15 +02001437/************************************************************************/
1438
Willy Tarreaua5e37562011-12-16 17:06:15 +01001439/* set temp integer to the number of connexions to the same listening socket */
Willy Tarreau645513a2010-05-24 20:55:15 +02001440static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001441smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau645513a2010-05-24 20:55:15 +02001442{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001443 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001444 smp->data.u.sint = smp->sess->listener->nbconn;
Willy Tarreau645513a2010-05-24 20:55:15 +02001445 return 1;
1446}
1447
Willy Tarreaua5e37562011-12-16 17:06:15 +01001448/* set temp integer to the id of the socket (listener) */
Willy Tarreau645513a2010-05-24 20:55:15 +02001449static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001450smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau37406352012-04-23 16:16:37 +02001451{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001452 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001453 smp->data.u.sint = smp->sess->listener->luid;
Willy Tarreau645513a2010-05-24 20:55:15 +02001454 return 1;
1455}
Jerome Magnineb421b22020-03-27 22:08:40 +01001456static int
1457smp_fetch_so_name(const struct arg *args, struct sample *smp, const char *kw, void *private)
1458{
1459 smp->data.u.str.area = smp->sess->listener->name;
1460 if (!smp->data.u.str.area)
1461 return 0;
1462
1463 smp->data.type = SMP_T_STR;
1464 smp->flags = SMP_F_CONST;
1465 smp->data.u.str.data = strlen(smp->data.u.str.area);
1466 return 1;
1467}
Willy Tarreau645513a2010-05-24 20:55:15 +02001468
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001469/* parse the "accept-proxy" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001470static 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 +02001471{
1472 struct listener *l;
1473
Willy Tarreau4348fad2012-09-20 16:48:07 +02001474 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001475 l->options |= LI_O_ACC_PROXY;
1476
1477 return 0;
1478}
1479
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001480/* parse the "accept-netscaler-cip" bind keyword */
1481static int bind_parse_accept_netscaler_cip(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1482{
1483 struct listener *l;
1484 uint32_t val;
1485
1486 if (!*args[cur_arg + 1]) {
1487 memprintf(err, "'%s' : missing value", args[cur_arg]);
1488 return ERR_ALERT | ERR_FATAL;
1489 }
1490
1491 val = atol(args[cur_arg + 1]);
1492 if (val <= 0) {
Willy Tarreaue2711c72019-02-27 15:39:41 +01001493 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001494 return ERR_ALERT | ERR_FATAL;
1495 }
1496
1497 list_for_each_entry(l, &conf->listeners, by_bind) {
1498 l->options |= LI_O_ACC_CIP;
1499 conf->ns_cip_magic = val;
1500 }
1501
1502 return 0;
1503}
1504
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001505/* parse the "backlog" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001506static 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 +02001507{
1508 struct listener *l;
1509 int val;
1510
1511 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001512 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001513 return ERR_ALERT | ERR_FATAL;
1514 }
1515
1516 val = atol(args[cur_arg + 1]);
Willy Tarreaue2711c72019-02-27 15:39:41 +01001517 if (val < 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001518 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001519 return ERR_ALERT | ERR_FATAL;
1520 }
1521
Willy Tarreau4348fad2012-09-20 16:48:07 +02001522 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001523 l->backlog = val;
1524
1525 return 0;
1526}
1527
1528/* parse the "id" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001529static 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 +02001530{
1531 struct eb32_node *node;
Willy Tarreau4348fad2012-09-20 16:48:07 +02001532 struct listener *l, *new;
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001533 char *error;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001534
Willy Tarreau4348fad2012-09-20 16:48:07 +02001535 if (conf->listeners.n != conf->listeners.p) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001536 memprintf(err, "'%s' can only be used with a single socket", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001537 return ERR_ALERT | ERR_FATAL;
1538 }
1539
1540 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001541 memprintf(err, "'%s' : expects an integer argument", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001542 return ERR_ALERT | ERR_FATAL;
1543 }
1544
Willy Tarreau4348fad2012-09-20 16:48:07 +02001545 new = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001546 new->luid = strtol(args[cur_arg + 1], &error, 10);
1547 if (*error != '\0') {
1548 memprintf(err, "'%s' : expects an integer argument, found '%s'", args[cur_arg], args[cur_arg + 1]);
1549 return ERR_ALERT | ERR_FATAL;
1550 }
Willy Tarreau4348fad2012-09-20 16:48:07 +02001551 new->conf.id.key = new->luid;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001552
Willy Tarreau4348fad2012-09-20 16:48:07 +02001553 if (new->luid <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001554 memprintf(err, "'%s' : custom id has to be > 0", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001555 return ERR_ALERT | ERR_FATAL;
1556 }
1557
Willy Tarreau4348fad2012-09-20 16:48:07 +02001558 node = eb32_lookup(&px->conf.used_listener_id, new->luid);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001559 if (node) {
1560 l = container_of(node, struct listener, conf.id);
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001561 memprintf(err, "'%s' : custom id %d already used at %s:%d ('bind %s')",
1562 args[cur_arg], l->luid, l->bind_conf->file, l->bind_conf->line,
1563 l->bind_conf->arg);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001564 return ERR_ALERT | ERR_FATAL;
1565 }
1566
Willy Tarreau4348fad2012-09-20 16:48:07 +02001567 eb32_insert(&px->conf.used_listener_id, &new->conf.id);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001568 return 0;
1569}
1570
Willy Tarreau3882d2a2022-05-20 15:41:45 +02001571/* Complete a bind_conf by parsing the args after the address. <args> is the
1572 * arguments array, <cur_arg> is the first one to be considered. <section> is
1573 * the section name to report in error messages, and <file> and <linenum> are
1574 * the file name and line number respectively. Note that args[0..1] are used
1575 * in error messages to provide some context. The return value is an error
1576 * code, zero on success or an OR of ERR_{FATAL,ABORT,ALERT,WARN}.
1577 */
1578int bind_parse_args_list(struct bind_conf *bind_conf, char **args, int cur_arg, const char *section, const char *file, int linenum)
1579{
1580 int err_code = 0;
1581
1582 while (*(args[cur_arg])) {
1583 struct bind_kw *kw;
1584 const char *best;
1585
1586 kw = bind_find_kw(args[cur_arg]);
1587 if (kw) {
1588 char *err = NULL;
1589 int code;
1590
1591 if (!kw->parse) {
1592 ha_alert("parsing [%s:%d] : '%s %s' in section '%s' : '%s' option is not implemented in this version (check build options).\n",
1593 file, linenum, args[0], args[1], section, args[cur_arg]);
1594 cur_arg += 1 + kw->skip ;
1595 err_code |= ERR_ALERT | ERR_FATAL;
1596 goto out;
1597 }
1598
1599 code = kw->parse(args, cur_arg, bind_conf->frontend, bind_conf, &err);
1600 err_code |= code;
1601
1602 if (code) {
1603 if (err && *err) {
1604 indent_msg(&err, 2);
1605 if (((code & (ERR_WARN|ERR_ALERT)) == ERR_WARN))
1606 ha_warning("parsing [%s:%d] : '%s %s' in section '%s' : %s\n", file, linenum, args[0], args[1], section, err);
1607 else
1608 ha_alert("parsing [%s:%d] : '%s %s' in section '%s' : %s\n", file, linenum, args[0], args[1], section, err);
1609 }
1610 else
1611 ha_alert("parsing [%s:%d] : '%s %s' in section '%s' : error encountered while processing '%s'.\n",
1612 file, linenum, args[0], args[1], section, args[cur_arg]);
1613 if (code & ERR_FATAL) {
1614 free(err);
1615 cur_arg += 1 + kw->skip;
1616 goto out;
1617 }
1618 }
1619 free(err);
1620 cur_arg += 1 + kw->skip;
1621 continue;
1622 }
1623
1624 best = bind_find_best_kw(args[cur_arg]);
1625 if (best)
1626 ha_alert("parsing [%s:%d] : '%s %s' in section '%s': unknown keyword '%s'; did you mean '%s' maybe ?\n",
1627 file, linenum, args[0], args[1], section, args[cur_arg], best);
1628 else
1629 ha_alert("parsing [%s:%d] : '%s %s' in section '%s': unknown keyword '%s'.\n",
1630 file, linenum, args[0], args[1], section, args[cur_arg]);
1631
1632 err_code |= ERR_ALERT | ERR_FATAL;
1633 goto out;
1634 }
Willy Tarreau64306cc2022-05-20 16:20:52 +02001635
1636 if ((bind_conf->options & (BC_O_USE_SOCK_DGRAM|BC_O_USE_SOCK_STREAM)) == (BC_O_USE_SOCK_DGRAM|BC_O_USE_SOCK_STREAM) ||
1637 (bind_conf->options & (BC_O_USE_XPRT_DGRAM|BC_O_USE_XPRT_STREAM)) == (BC_O_USE_XPRT_DGRAM|BC_O_USE_XPRT_STREAM)) {
1638 ha_alert("parsing [%s:%d] : '%s %s' in section '%s' : cannot mix datagram and stream protocols.\n",
1639 file, linenum, args[0], args[1], section);
1640 err_code |= ERR_ALERT | ERR_FATAL;
1641 goto out;
1642 }
1643
Willy Tarreau78d0dcd2022-05-20 17:10:00 +02001644 /* The transport layer automatically switches to QUIC when QUIC is
1645 * selected, regardless of bind_conf settings. We then need to
1646 * initialize QUIC params.
1647 */
1648 if ((bind_conf->options & (BC_O_USE_SOCK_DGRAM|BC_O_USE_XPRT_STREAM)) == (BC_O_USE_SOCK_DGRAM|BC_O_USE_XPRT_STREAM)) {
1649#ifdef USE_QUIC
1650 bind_conf->xprt = xprt_get(XPRT_QUIC);
Willy Tarreau287f32f2022-05-20 18:16:52 +02001651 if (!(bind_conf->options & BC_O_USE_SSL)) {
1652 bind_conf->options |= BC_O_USE_SSL;
1653 ha_warning("parsing [%s:%d] : '%s %s' in section '%s' : QUIC protocol detected, enabling ssl. Use 'ssl' to shut this warning.\n",
1654 file, linenum, args[0], args[1], section);
1655 }
Willy Tarreau78d0dcd2022-05-20 17:10:00 +02001656 quic_transport_params_init(&bind_conf->quic_params, 1);
1657#else
1658 ha_alert("parsing [%s:%d] : '%s %s' in section '%s' : QUIC protocol selected but support not compiled in (check build options).\n",
1659 file, linenum, args[0], args[1], section);
1660 err_code |= ERR_ALERT | ERR_FATAL;
1661 goto out;
1662#endif
1663 }
Willy Tarreau2071a992022-05-20 17:14:31 +02001664 else if (bind_conf->options & BC_O_USE_SSL) {
1665 bind_conf->xprt = xprt_get(XPRT_SSL);
1666 }
Willy Tarreau78d0dcd2022-05-20 17:10:00 +02001667
Willy Tarreau3882d2a2022-05-20 15:41:45 +02001668 out:
1669 return err_code;
1670}
1671
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001672/* parse the "maxconn" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001673static 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 +02001674{
1675 struct listener *l;
1676 int val;
1677
1678 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001679 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001680 return ERR_ALERT | ERR_FATAL;
1681 }
1682
1683 val = atol(args[cur_arg + 1]);
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001684 if (val < 0) {
1685 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001686 return ERR_ALERT | ERR_FATAL;
1687 }
1688
Willy Tarreau4348fad2012-09-20 16:48:07 +02001689 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001690 l->maxconn = val;
1691
1692 return 0;
1693}
1694
1695/* parse the "name" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001696static 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 +02001697{
1698 struct listener *l;
1699
1700 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001701 memprintf(err, "'%s' : missing name", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001702 return ERR_ALERT | ERR_FATAL;
1703 }
1704
Willy Tarreau4348fad2012-09-20 16:48:07 +02001705 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001706 l->name = strdup(args[cur_arg + 1]);
1707
1708 return 0;
1709}
1710
1711/* parse the "nice" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001712static 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 +02001713{
1714 struct listener *l;
1715 int val;
1716
1717 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001718 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001719 return ERR_ALERT | ERR_FATAL;
1720 }
1721
1722 val = atol(args[cur_arg + 1]);
1723 if (val < -1024 || val > 1024) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001724 memprintf(err, "'%s' : invalid value %d, allowed range is -1024..1024", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001725 return ERR_ALERT | ERR_FATAL;
1726 }
1727
Willy Tarreau4348fad2012-09-20 16:48:07 +02001728 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001729 l->nice = val;
1730
1731 return 0;
1732}
1733
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001734/* parse the "process" bind keyword */
1735static int bind_parse_process(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1736{
Christopher Fauletc644fa92017-11-23 22:44:11 +01001737 char *slash;
1738 unsigned long proc = 0, thread = 0;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001739
Christopher Fauletc644fa92017-11-23 22:44:11 +01001740 if ((slash = strchr(args[cur_arg + 1], '/')) != NULL)
1741 *slash = 0;
1742
Willy Tarreau72faef32021-06-15 08:36:30 +02001743 if (parse_process_number(args[cur_arg + 1], &proc, 1, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +01001744 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001745 return ERR_ALERT | ERR_FATAL;
1746 }
1747
Christopher Fauletc644fa92017-11-23 22:44:11 +01001748 if (slash) {
Willy Tarreauc9a82e42019-01-26 13:25:14 +01001749 if (parse_process_number(slash+1, &thread, MAX_THREADS, NULL, err)) {
Christopher Fauletc644fa92017-11-23 22:44:11 +01001750 memprintf(err, "'%s' : %s", args[cur_arg], *err);
1751 return ERR_ALERT | ERR_FATAL;
1752 }
1753 *slash = '/';
1754 }
1755
Willy Tarreau01cac3f2021-10-12 08:47:54 +02001756 conf->bind_thread |= thread;
Willy Tarreauc8cac042021-09-21 14:31:29 +02001757
1758 memprintf(err, "'process %s' on 'bind' lines is deprecated and will be removed in 2.7.", args[cur_arg+1]);
1759 if (slash)
1760 memprintf(err, "%s Please use 'thread %s' instead.", *err, slash + 1);
1761 return ERR_WARN;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001762}
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001763
Christopher Fauleta717b992018-04-10 14:43:00 +02001764/* parse the "proto" bind keyword */
1765static int bind_parse_proto(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1766{
1767 struct ist proto;
1768
1769 if (!*args[cur_arg + 1]) {
1770 memprintf(err, "'%s' : missing value", args[cur_arg]);
1771 return ERR_ALERT | ERR_FATAL;
1772 }
1773
Tim Duesterhusdcf753a2021-03-04 17:31:47 +01001774 proto = ist(args[cur_arg + 1]);
Christopher Fauleta717b992018-04-10 14:43:00 +02001775 conf->mux_proto = get_mux_proto(proto);
1776 if (!conf->mux_proto) {
1777 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[cur_arg], args[cur_arg+1]);
1778 return ERR_ALERT | ERR_FATAL;
1779 }
Willy Tarreauc8cac042021-09-21 14:31:29 +02001780 return 0;
1781}
1782
Willy Tarreau6dfbef42021-10-12 15:23:03 +02001783/* parse the "shards" bind keyword. Takes an integer or "by-thread" */
1784static int bind_parse_shards(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1785{
1786 int val;
1787
1788 if (!*args[cur_arg + 1]) {
1789 memprintf(err, "'%s' : missing value", args[cur_arg]);
1790 return ERR_ALERT | ERR_FATAL;
1791 }
1792
1793 if (strcmp(args[cur_arg + 1], "by-thread") == 0) {
1794 val = MAX_THREADS; /* will be trimmed later anyway */
1795 } else {
1796 val = atol(args[cur_arg + 1]);
1797 if (val < 1 || val > MAX_THREADS) {
1798 memprintf(err, "'%s' : invalid value %d, allowed range is %d..%d or 'by-thread'", args[cur_arg], val, 1, MAX_THREADS);
1799 return ERR_ALERT | ERR_FATAL;
1800 }
1801 }
1802
1803 conf->settings.shards = val;
1804 return 0;
1805}
1806
Willy Tarreauc8cac042021-09-21 14:31:29 +02001807/* parse the "thread" bind keyword */
1808static int bind_parse_thread(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1809{
Willy Tarreaud57b9ff2021-09-29 18:50:31 +02001810 char *sep = NULL;
1811 ulong thread = 0;
1812 long tgroup = 0;
Willy Tarreauc8cac042021-09-21 14:31:29 +02001813
Willy Tarreaud57b9ff2021-09-29 18:50:31 +02001814 tgroup = strtol(args[cur_arg + 1], &sep, 10);
1815 if (*sep == '/') {
1816 /* a thread group was present */
1817 if (tgroup < 1 || tgroup > MAX_TGROUPS) {
1818 memprintf(err, "'%s' thread-group number must be between 1 and %d (was %ld)", args[cur_arg + 1], MAX_TGROUPS, tgroup);
1819 return ERR_ALERT | ERR_FATAL;
1820 }
1821 sep++;
1822 }
1823 else {
1824 /* no thread group */
1825 tgroup = 0;
1826 sep = args[cur_arg + 1];
1827 }
Willy Tarreauc8cac042021-09-21 14:31:29 +02001828
Willy Tarreau01cac3f2021-10-12 08:47:54 +02001829 if ((conf->bind_tgroup || conf->bind_thread) &&
1830 conf->bind_tgroup != tgroup) {
Willy Tarreaud57b9ff2021-09-29 18:50:31 +02001831 memprintf(err, "'%s' multiple thread-groups are not supported", args[cur_arg + 1]);
Willy Tarreauc8cac042021-09-21 14:31:29 +02001832 return ERR_ALERT | ERR_FATAL;
1833 }
Willy Tarreaud57b9ff2021-09-29 18:50:31 +02001834
1835 if (parse_process_number(sep, &thread, MAX_THREADS, NULL, err)) {
1836 memprintf(err, "'%s' : %s", sep, *err);
Willy Tarreauc8cac042021-09-21 14:31:29 +02001837 return ERR_ALERT | ERR_FATAL;
1838 }
1839
Willy Tarreau01cac3f2021-10-12 08:47:54 +02001840 conf->bind_thread |= thread;
1841 conf->bind_tgroup = tgroup;
Christopher Fauleta717b992018-04-10 14:43:00 +02001842 return 0;
1843}
1844
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001845/* config parser for global "tune.listener.multi-queue", accepts "on" or "off" */
1846static int cfg_parse_tune_listener_mq(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01001847 const struct proxy *defpx, const char *file, int line,
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001848 char **err)
1849{
1850 if (too_many_args(1, args, err, NULL))
1851 return -1;
1852
1853 if (strcmp(args[1], "on") == 0)
1854 global.tune.options |= GTUNE_LISTENER_MQ;
1855 else if (strcmp(args[1], "off") == 0)
1856 global.tune.options &= ~GTUNE_LISTENER_MQ;
1857 else {
1858 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
1859 return -1;
1860 }
1861 return 0;
1862}
1863
Willy Tarreau61612d42012-04-19 18:42:05 +02001864/* Note: must not be declared <const> as its list will be overwritten.
1865 * Please take care of keeping this list alphabetically sorted.
1866 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001867static struct sample_fetch_kw_list smp_kws = {ILH, {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001868 { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
1869 { "so_id", smp_fetch_so_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
Jerome Magnineb421b22020-03-27 22:08:40 +01001870 { "so_name", smp_fetch_so_name, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001871 { /* END */ },
1872}};
1873
Willy Tarreau0108d902018-11-25 19:14:37 +01001874INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1875
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001876/* Note: must not be declared <const> as its list will be overwritten.
1877 * Please take care of keeping this list alphabetically sorted.
1878 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001879static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001880 { /* END */ },
Willy Tarreau645513a2010-05-24 20:55:15 +02001881}};
1882
Willy Tarreau0108d902018-11-25 19:14:37 +01001883INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
1884
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001885/* Note: must not be declared <const> as its list will be overwritten.
1886 * Please take care of keeping this list alphabetically sorted, doing so helps
1887 * all code contributors.
1888 * Optional keywords are also declared with a NULL ->parse() function so that
1889 * the config parser can report an appropriate error when a known keyword was
1890 * not enabled.
1891 */
Willy Tarreau51fb7652012-09-18 18:24:39 +02001892static struct bind_kw_list bind_kws = { "ALL", { }, {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001893 { "accept-netscaler-cip", bind_parse_accept_netscaler_cip, 1 }, /* enable NetScaler Client IP insertion protocol */
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001894 { "accept-proxy", bind_parse_accept_proxy, 0 }, /* enable PROXY protocol */
1895 { "backlog", bind_parse_backlog, 1 }, /* set backlog of listening socket */
1896 { "id", bind_parse_id, 1 }, /* set id of listening socket */
1897 { "maxconn", bind_parse_maxconn, 1 }, /* set maxconn of listening socket */
1898 { "name", bind_parse_name, 1 }, /* set name of listening socket */
1899 { "nice", bind_parse_nice, 1 }, /* set nice of listening socket */
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001900 { "process", bind_parse_process, 1 }, /* set list of allowed process for this socket */
Christopher Fauleta717b992018-04-10 14:43:00 +02001901 { "proto", bind_parse_proto, 1 }, /* set the proto to use for all incoming connections */
Willy Tarreau6dfbef42021-10-12 15:23:03 +02001902 { "shards", bind_parse_shards, 1 }, /* set number of shards */
Willy Tarreauc8cac042021-09-21 14:31:29 +02001903 { "thread", bind_parse_thread, 1 }, /* set list of allowed threads for this socket */
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001904 { /* END */ },
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001905}};
1906
Willy Tarreau0108d902018-11-25 19:14:37 +01001907INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
1908
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001909/* config keyword parsers */
1910static struct cfg_kw_list cfg_kws = {ILH, {
1911 { CFG_GLOBAL, "tune.listener.multi-queue", cfg_parse_tune_listener_mq },
1912 { 0, NULL, NULL }
1913}};
1914
1915INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1916
Willy Tarreau645513a2010-05-24 20:55:15 +02001917/*
1918 * Local variables:
1919 * c-indent-level: 8
1920 * c-basic-offset: 8
1921 * End:
1922 */