blob: ad9d95a14542037c3aed6eeae8129187da540bb5 [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>
18#include <fcntl.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020019
Willy Tarreaudcc048a2020-06-04 19:11:43 +020020#include <haproxy/acl.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020021#include <haproxy/api.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020022#include <haproxy/cfgparse.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020023#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020024#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020025#include <haproxy/fd.h>
26#include <haproxy/freq_ctr.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020027#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020028#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020029#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020030#include <haproxy/log.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/protocol.h>
Willy Tarreau5958c432021-05-08 20:30:37 +020032#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020033#include <haproxy/sample.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020034#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020035#include <haproxy/task.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020036#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/tools.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020038
Willy Tarreaub648d632007-10-28 22:13:50 +010039
Willy Tarreau26982662012-09-12 23:17:10 +020040/* List head of all known bind keywords */
41static struct bind_kw_list bind_keywords = {
42 .list = LIST_HEAD_INIT(bind_keywords.list)
43};
44
Willy Tarreaua1d97f82019-12-10 11:18:41 +010045/* list of the temporarily limited listeners because of lack of resource */
46static struct mt_list global_listener_queue = MT_LIST_HEAD_INIT(global_listener_queue);
47static struct task *global_listener_queue_task;
Willy Tarreau49a2f602022-11-22 09:08:23 +010048__decl_thread(static HA_RWLOCK_T global_listener_rwlock);
Willy Tarreaua1d97f82019-12-10 11:18:41 +010049
William Dauchy3679d0c2021-02-14 23:22:55 +010050/* listener status for stats */
51const char* li_status_st[LI_STATE_COUNT] = {
52 [LI_STATUS_WAITING] = "WAITING",
53 [LI_STATUS_OPEN] = "OPEN",
54 [LI_STATUS_FULL] = "FULL",
55};
Willy Tarreaua1d97f82019-12-10 11:18:41 +010056
Willy Tarreau1efafce2019-01-27 15:37:19 +010057#if defined(USE_THREAD)
58
59struct accept_queue_ring accept_queue_rings[MAX_THREADS] __attribute__((aligned(64))) = { };
60
61/* dequeue and process a pending connection from the local accept queue (single
Willy Tarreau83efc322020-10-14 17:37:17 +020062 * consumer). Returns the accepted connection or NULL if none was found.
Willy Tarreau1efafce2019-01-27 15:37:19 +010063 */
Willy Tarreau83efc322020-10-14 17:37:17 +020064struct connection *accept_queue_pop_sc(struct accept_queue_ring *ring)
Willy Tarreau1efafce2019-01-27 15:37:19 +010065{
Willy Tarreau1efafce2019-01-27 15:37:19 +010066 unsigned int pos, next;
Willy Tarreau83efc322020-10-14 17:37:17 +020067 struct connection *ptr;
68 struct connection **e;
Willy Tarreau1efafce2019-01-27 15:37:19 +010069
70 pos = ring->head;
71
72 if (pos == ring->tail)
Willy Tarreau83efc322020-10-14 17:37:17 +020073 return NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +010074
75 next = pos + 1;
76 if (next >= ACCEPT_QUEUE_SIZE)
77 next = 0;
78
79 e = &ring->entry[pos];
80
81 /* wait for the producer to update the listener's pointer */
82 while (1) {
Willy Tarreau83efc322020-10-14 17:37:17 +020083 ptr = *e;
Willy Tarreau1efafce2019-01-27 15:37:19 +010084 __ha_barrier_load();
85 if (ptr)
86 break;
87 pl_cpu_relax();
88 }
89
Willy Tarreau1efafce2019-01-27 15:37:19 +010090 /* release the entry */
Willy Tarreau83efc322020-10-14 17:37:17 +020091 *e = NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +010092
93 __ha_barrier_store();
94 ring->head = next;
Willy Tarreau83efc322020-10-14 17:37:17 +020095 return ptr;
Willy Tarreau1efafce2019-01-27 15:37:19 +010096}
97
98
Willy Tarreau83efc322020-10-14 17:37:17 +020099/* tries to push a new accepted connection <conn> into ring <ring>. Returns
100 * non-zero if it succeeds, or zero if the ring is full. Supports multiple
101 * producers.
Willy Tarreau1efafce2019-01-27 15:37:19 +0100102 */
Willy Tarreau83efc322020-10-14 17:37:17 +0200103int accept_queue_push_mp(struct accept_queue_ring *ring, struct connection *conn)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100104{
Willy Tarreau1efafce2019-01-27 15:37:19 +0100105 unsigned int pos, next;
106
107 pos = ring->tail;
108 do {
109 next = pos + 1;
110 if (next >= ACCEPT_QUEUE_SIZE)
111 next = 0;
112 if (next == ring->head)
113 return 0; // ring full
Olivier Houchard64213e92019-03-08 18:52:57 +0100114 } while (unlikely(!_HA_ATOMIC_CAS(&ring->tail, &pos, next)));
Willy Tarreau1efafce2019-01-27 15:37:19 +0100115
Willy Tarreau83efc322020-10-14 17:37:17 +0200116 ring->entry[pos] = conn;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100117 __ha_barrier_store();
Willy Tarreau1efafce2019-01-27 15:37:19 +0100118 return 1;
119}
120
Willy Tarreaufb5401f2021-01-29 12:25:23 +0100121/* proceed with accepting new connections. Don't mark it static so that it appears
122 * in task dumps.
123 */
Willy Tarreau144f84a2021-03-02 16:09:26 +0100124struct task *accept_queue_process(struct task *t, void *context, unsigned int state)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100125{
126 struct accept_queue_ring *ring = context;
Willy Tarreau83efc322020-10-14 17:37:17 +0200127 struct connection *conn;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100128 struct listener *li;
Christopher Faulet102854c2019-04-30 12:17:13 +0200129 unsigned int max_accept;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100130 int ret;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100131
Christopher Faulet102854c2019-04-30 12:17:13 +0200132 /* if global.tune.maxaccept is -1, then max_accept is UINT_MAX. It
133 * is not really illimited, but it is probably enough.
134 */
Willy Tarreau66161322021-02-19 15:50:27 +0100135 max_accept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Christopher Faulet102854c2019-04-30 12:17:13 +0200136 for (; max_accept; max_accept--) {
Willy Tarreau83efc322020-10-14 17:37:17 +0200137 conn = accept_queue_pop_sc(ring);
138 if (!conn)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100139 break;
140
Willy Tarreau83efc322020-10-14 17:37:17 +0200141 li = __objt_listener(conn->target);
Willy Tarreau4781b152021-04-06 13:53:36 +0200142 _HA_ATOMIC_INC(&li->thr_conn[tid]);
Willy Tarreau83efc322020-10-14 17:37:17 +0200143 ret = li->accept(conn);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100144 if (ret <= 0) {
145 /* connection was terminated by the application */
146 continue;
147 }
148
149 /* increase the per-process number of cumulated sessions, this
150 * may only be done once l->accept() has accepted the connection.
151 */
152 if (!(li->options & LI_O_UNLIMITED)) {
153 HA_ATOMIC_UPDATE_MAX(&global.sps_max,
154 update_freq_ctr(&global.sess_per_sec, 1));
155 if (li->bind_conf && li->bind_conf->is_ssl) {
156 HA_ATOMIC_UPDATE_MAX(&global.ssl_max,
157 update_freq_ctr(&global.ssl_per_sec, 1));
158 }
159 }
160 }
161
162 /* ran out of budget ? Let's come here ASAP */
Christopher Faulet102854c2019-04-30 12:17:13 +0200163 if (!max_accept)
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200164 tasklet_wakeup(ring->tasklet);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100165
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200166 return NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100167}
168
169/* Initializes the accept-queues. Returns 0 on success, otherwise ERR_* flags */
170static int accept_queue_init()
171{
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200172 struct tasklet *t;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100173 int i;
174
175 for (i = 0; i < global.nbthread; i++) {
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200176 t = tasklet_new();
Willy Tarreau1efafce2019-01-27 15:37:19 +0100177 if (!t) {
178 ha_alert("Out of memory while initializing accept queue for thread %d\n", i);
179 return ERR_FATAL|ERR_ABORT;
180 }
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200181 t->tid = i;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100182 t->process = accept_queue_process;
183 t->context = &accept_queue_rings[i];
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200184 accept_queue_rings[i].tasklet = t;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100185 }
186 return 0;
187}
188
189REGISTER_CONFIG_POSTPARSER("multi-threaded accept queue", accept_queue_init);
190
191#endif // USE_THREAD
192
William Dauchy3679d0c2021-02-14 23:22:55 +0100193/* helper to get listener status for stats */
194enum li_status get_li_status(struct listener *l)
195{
196 if (!l->maxconn || l->nbconn < l->maxconn) {
197 if (l->state == LI_LIMITED)
198 return LI_STATUS_WAITING;
199 else
200 return LI_STATUS_OPEN;
201 }
202 return LI_STATUS_FULL;
203}
204
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200205/* adjust the listener's state and its proxy's listener counters if needed.
206 * It must be called under the listener's lock, but uses atomic ops to change
207 * the proxy's counters so that the proxy lock is not needed.
208 */
Willy Tarreaua37b2442020-09-24 07:23:45 +0200209void listener_set_state(struct listener *l, enum li_state st)
210{
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200211 struct proxy *px = l->bind_conf->frontend;
212
213 if (px) {
214 /* from state */
215 switch (l->state) {
216 case LI_NEW: /* first call */
Willy Tarreau4781b152021-04-06 13:53:36 +0200217 _HA_ATOMIC_INC(&px->li_all);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200218 break;
219 case LI_INIT:
220 case LI_ASSIGNED:
221 break;
222 case LI_PAUSED:
Willy Tarreau4781b152021-04-06 13:53:36 +0200223 _HA_ATOMIC_DEC(&px->li_paused);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200224 break;
225 case LI_LISTEN:
Willy Tarreau4781b152021-04-06 13:53:36 +0200226 _HA_ATOMIC_DEC(&px->li_bound);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200227 break;
228 case LI_READY:
229 case LI_FULL:
230 case LI_LIMITED:
Willy Tarreau4781b152021-04-06 13:53:36 +0200231 _HA_ATOMIC_DEC(&px->li_ready);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200232 break;
233 }
234
235 /* to state */
236 switch (st) {
237 case LI_NEW:
238 case LI_INIT:
239 case LI_ASSIGNED:
240 break;
241 case LI_PAUSED:
Willy Tarreau95a34602020-10-08 15:32:21 +0200242 BUG_ON(l->rx.fd == -1);
Willy Tarreau4781b152021-04-06 13:53:36 +0200243 _HA_ATOMIC_INC(&px->li_paused);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200244 break;
245 case LI_LISTEN:
Willy Tarreau95a34602020-10-08 15:32:21 +0200246 BUG_ON(l->rx.fd == -1);
Willy Tarreau4781b152021-04-06 13:53:36 +0200247 _HA_ATOMIC_INC(&px->li_bound);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200248 break;
249 case LI_READY:
250 case LI_FULL:
251 case LI_LIMITED:
Willy Tarreau95a34602020-10-08 15:32:21 +0200252 BUG_ON(l->rx.fd == -1);
Willy Tarreau4781b152021-04-06 13:53:36 +0200253 _HA_ATOMIC_INC(&px->li_ready);
Aurelien DARRAGON3b78de12023-02-14 08:51:14 +0100254 l->flags |= LI_F_FINALIZED;
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200255 break;
256 }
257 }
Willy Tarreaua37b2442020-09-24 07:23:45 +0200258 l->state = st;
259}
260
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100261/* This function adds the specified listener's file descriptor to the polling
262 * lists if it is in the LI_LISTEN state. The listener enters LI_READY or
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500263 * LI_FULL state depending on its number of connections. In daemon mode, we
Willy Tarreauae302532014-05-07 19:22:24 +0200264 * also support binding only the relevant processes to their respective
265 * listeners. We don't do that in debug mode however.
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100266 */
Willy Tarreau7834a3f2020-09-25 16:40:18 +0200267void enable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100268{
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100269 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaud6afb532020-10-09 10:35:40 +0200270
271 /* If this listener is supposed to be only in the master, close it in
272 * the workers. Conversely, if it's supposed to be only in the workers
273 * close it in the master.
274 */
Willy Tarreau18c20d22020-10-09 16:11:46 +0200275 if (!!master != !!(listener->rx.flags & RX_F_MWORKER))
Willy Tarreau75c98d12020-10-09 15:55:23 +0200276 do_unbind_listener(listener);
Willy Tarreaud6afb532020-10-09 10:35:40 +0200277
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100278 if (listener->state == LI_LISTEN) {
Willy Tarreau95a34602020-10-08 15:32:21 +0200279 BUG_ON(listener->rx.fd == -1);
William Lallemand095ba4c2017-06-01 17:38:50 +0200280 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau38dba272020-11-04 13:54:00 +0100281 (!!master != !!(listener->rx.flags & RX_F_MWORKER) ||
282 !(proc_mask(listener->rx.settings->bind_proc) & pid_bit))) {
Willy Tarreauae302532014-05-07 19:22:24 +0200283 /* we don't want to enable this listener and don't
284 * want any fd event to reach it.
285 */
Willy Tarreau75c98d12020-10-09 15:55:23 +0200286 do_unbind_listener(listener);
Willy Tarreauae302532014-05-07 19:22:24 +0200287 }
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100288 else if (!listener->maxconn || listener->nbconn < listener->maxconn) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200289 listener->rx.proto->enable(listener);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200290 listener_set_state(listener, LI_READY);
Willy Tarreauae302532014-05-07 19:22:24 +0200291 }
292 else {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200293 listener_set_state(listener, LI_FULL);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100294 }
295 }
Willy Tarreaud6afb532020-10-09 10:35:40 +0200296
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100297 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100298}
299
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200300/*
Aurelien DARRAGON7c9e1f92022-09-11 16:19:49 +0200301 * This function completely stops a listener.
302 * The proxy's listeners count is updated and the proxy is
303 * disabled and woken up after the last one is gone.
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100304 * It will need to operate under the proxy's lock, the protocol's lock and
305 * the listener's lock. The caller is responsible for indicating in lpx,
306 * lpr, lli whether the respective locks are already held (non-zero) or
307 * not (zero) so that the function picks the missing ones, in this order.
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200308 */
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100309void stop_listener(struct listener *l, int lpx, int lpr, int lli)
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200310{
311 struct proxy *px = l->bind_conf->frontend;
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200312
313 if (l->options & LI_O_NOSTOP) {
314 /* master-worker sockpairs are never closed but don't count as a
315 * job.
316 */
317 return;
318 }
319
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200320 if (!lpx && px)
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200321 HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200322
323 if (!lpr)
324 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
325
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100326 if (!lli)
327 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200328
329 if (l->state > LI_INIT) {
Willy Tarreau75c98d12020-10-09 15:55:23 +0200330 do_unbind_listener(l);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200331
332 if (l->state >= LI_ASSIGNED)
333 __delete_listener(l);
334
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200335 if (px)
336 proxy_cond_disable(px);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200337 }
338
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100339 if (!lli)
340 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200341
342 if (!lpr)
343 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
344
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200345 if (!lpx && px)
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200346 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &px->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200347}
348
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100349/* This function adds the specified <listener> to the protocol <proto>. It
350 * does nothing if the protocol was already added. The listener's state is
351 * automatically updated from LI_INIT to LI_ASSIGNED. The number of listeners
352 * for the protocol is updated. This must be called with the proto lock held.
353 */
354void default_add_listener(struct protocol *proto, struct listener *listener)
355{
356 if (listener->state != LI_INIT)
357 return;
358 listener_set_state(listener, LI_ASSIGNED);
359 listener->rx.proto = proto;
Willy Tarreau2b718102021-04-21 07:32:39 +0200360 LIST_APPEND(&proto->receivers, &listener->rx.proto_list);
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100361 proto->nb_receivers++;
362}
363
Willy Tarreaue03204c2020-10-09 17:02:21 +0200364/* default function called to suspend a listener: it simply passes the call to
365 * the underlying receiver. This is find for most socket-based protocols. This
Aurelien DARRAGON39f16152023-02-07 11:23:38 +0100366 * must be called under the listener's lock. It will return < 0 in case of
367 * failure, 0 if the listener was totally stopped, or > 0 if correctly paused..
368 * If no receiver-level suspend is provided, the operation is assumed
369 * to succeed.
Willy Tarreaue03204c2020-10-09 17:02:21 +0200370 */
371int default_suspend_listener(struct listener *l)
372{
Willy Tarreaue03204c2020-10-09 17:02:21 +0200373 if (!l->rx.proto->rx_suspend)
374 return 1;
375
Aurelien DARRAGON39f16152023-02-07 11:23:38 +0100376 return l->rx.proto->rx_suspend(&l->rx);
Willy Tarreaue03204c2020-10-09 17:02:21 +0200377}
378
379
380/* Tries to resume a suspended listener, and returns non-zero on success or
381 * zero on failure. On certain errors, an alert or a warning might be displayed.
382 * It must be called with the listener's lock held. Depending on the listener's
383 * state and protocol, a listen() call might be used to resume operations, or a
384 * call to the receiver's resume() function might be used as well. This is
385 * suitable as a default function for TCP and UDP. This must be called with the
386 * listener's lock held.
387 */
388int default_resume_listener(struct listener *l)
389{
390 int ret = 1;
391
392 if (l->state == LI_ASSIGNED) {
393 char msg[100];
Aurelien DARRAGONd41af3e2023-02-07 12:17:20 +0100394 char *errmsg;
Willy Tarreaue03204c2020-10-09 17:02:21 +0200395 int err;
396
Aurelien DARRAGONd41af3e2023-02-07 12:17:20 +0100397 /* first, try to bind the receiver */
398 err = l->rx.proto->fam->bind(&l->rx, &errmsg);
399 if (err != ERR_NONE) {
400 if (err & ERR_WARN)
401 ha_warning("Resuming listener: %s\n", errmsg);
402 else if (err & ERR_ALERT)
403 ha_alert("Resuming listener: %s\n", errmsg);
404 ha_free(&errmsg);
405 if (err & (ERR_FATAL | ERR_ABORT)) {
406 ret = 0;
407 goto end;
408 }
409 }
410
411 /* then, try to listen:
412 * for now there's still always a listening function
413 * (same check performed in protocol_bind_all()
414 */
415 BUG_ON(!l->rx.proto->listen);
Willy Tarreaue03204c2020-10-09 17:02:21 +0200416 err = l->rx.proto->listen(l, msg, sizeof(msg));
417 if (err & ERR_ALERT)
418 ha_alert("Resuming listener: %s\n", msg);
419 else if (err & ERR_WARN)
420 ha_warning("Resuming listener: %s\n", msg);
421
422 if (err & (ERR_FATAL | ERR_ABORT)) {
423 ret = 0;
424 goto end;
425 }
426 }
427
428 if (l->state < LI_PAUSED) {
429 ret = 0;
430 goto end;
431 }
432
433 if (l->state == LI_PAUSED && l->rx.proto->rx_resume &&
434 l->rx.proto->rx_resume(&l->rx) <= 0)
435 ret = 0;
436 end:
437 return ret;
438}
439
440
Willy Tarreaube58c382011-07-24 18:28:10 +0200441/* This function tries to temporarily disable a listener, depending on the OS
442 * capabilities. Linux unbinds the listen socket after a SHUT_RD, and ignores
443 * SHUT_WR. Solaris refuses either shutdown(). OpenBSD ignores SHUT_RD but
444 * closes upon SHUT_WR and refuses to rebind. So a common validation path
445 * involves SHUT_WR && listen && SHUT_RD. In case of success, the FD's polling
446 * is disabled. It normally returns non-zero, unless an error is reported.
Aurelien DARRAGON8283d592023-02-13 17:45:08 +0100447 * suspend() may totally stop a listener if it doesn't support the PAUSED
448 * state, in which case state will be set to ASSIGNED.
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100449 * It will need to operate under the proxy's lock and the listener's lock.
450 * The caller is responsible for indicating in lpx, lli whether the respective
451 * locks are already held (non-zero) or not (zero) so that the function pick
452 * the missing ones, in this order.
Willy Tarreaube58c382011-07-24 18:28:10 +0200453 */
Aurelien DARRAGON8283d592023-02-13 17:45:08 +0100454int suspend_listener(struct listener *l, int lpx, int lli)
Willy Tarreaube58c382011-07-24 18:28:10 +0200455{
Willy Tarreau58651b42020-09-24 16:03:29 +0200456 struct proxy *px = l->bind_conf->frontend;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200457 int ret = 1;
458
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200459 if (!lpx && px)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200460 HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock);
461
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100462 if (!lli)
463 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200464
Willy Tarreau02e19752020-09-23 17:17:22 +0200465 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
466 !(proc_mask(l->rx.settings->bind_proc) & pid_bit))
467 goto end;
468
Aurelien DARRAGON3b78de12023-02-14 08:51:14 +0100469 if (!(l->flags & LI_F_FINALIZED) || l->state <= LI_PAUSED)
Willy Tarreau9b3a9322020-09-24 14:46:34 +0200470 goto end;
471
Aurelien DARRAGON39f16152023-02-07 11:23:38 +0100472 if (l->rx.proto->suspend) {
Willy Tarreaue03204c2020-10-09 17:02:21 +0200473 ret = l->rx.proto->suspend(l);
Aurelien DARRAGON39f16152023-02-07 11:23:38 +0100474 /* if the suspend() fails, we don't want to change the
475 * current listener state
476 */
477 if (ret < 0)
478 goto end;
479 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200480
Willy Tarreau2b718102021-04-21 07:32:39 +0200481 MT_LIST_DELETE(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200482
Aurelien DARRAGON39f16152023-02-07 11:23:38 +0100483 /* ret == 0 means that the suspend() has been turned into
484 * an unbind(), meaning the listener is now stopped (ie: ABNS), we need
485 * to report this state change properly
486 */
487 listener_set_state(l, ((ret) ? LI_PAUSED : LI_ASSIGNED));
488
Aurelien DARRAGON8283d592023-02-13 17:45:08 +0100489 if (px && !(l->flags & LI_F_SUSPENDED))
490 px->li_suspended++;
491 l->flags |= LI_F_SUSPENDED;
492
Aurelien DARRAGON39f16152023-02-07 11:23:38 +0100493 /* at this point, everything is under control, no error should be
494 * returned to calling function
495 */
496 ret = 1;
Willy Tarreau58651b42020-09-24 16:03:29 +0200497
498 if (px && !px->li_ready) {
499 ha_warning("Paused %s %s.\n", proxy_cap_str(px->cap), px->id);
500 send_log(px, LOG_WARNING, "Paused %s %s.\n", proxy_cap_str(px->cap), px->id);
501 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200502 end:
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100503 if (!lli)
504 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200505
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200506 if (!lpx && px)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200507 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &px->lock);
508
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200509 return ret;
Willy Tarreaube58c382011-07-24 18:28:10 +0200510}
511
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200512/* This function tries to resume a temporarily disabled listener. Paused, full,
513 * limited and disabled listeners are handled, which means that this function
514 * may replace enable_listener(). The resulting state will either be LI_READY
515 * or LI_FULL. 0 is returned in case of failure to resume (eg: dead socket).
Willy Tarreauae302532014-05-07 19:22:24 +0200516 * Listeners bound to a different process are not woken up unless we're in
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200517 * foreground mode, and are ignored. If the listener was only in the assigned
Aurelien DARRAGON8283d592023-02-13 17:45:08 +0100518 * state, it's totally rebound. This can happen if a suspend() has completely
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200519 * stopped it. If the resume fails, 0 is returned and an error might be
520 * displayed.
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100521 * It will need to operate under the proxy's lock and the listener's lock.
522 * The caller is responsible for indicating in lpx, lli whether the respective
523 * locks are already held (non-zero) or not (zero) so that the function pick
524 * the missing ones, in this order.
Willy Tarreaube58c382011-07-24 18:28:10 +0200525 */
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100526int resume_listener(struct listener *l, int lpx, int lli)
Willy Tarreaube58c382011-07-24 18:28:10 +0200527{
Willy Tarreau58651b42020-09-24 16:03:29 +0200528 struct proxy *px = l->bind_conf->frontend;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200529 int ret = 1;
530
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200531 if (!lpx && px)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200532 HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock);
533
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100534 if (!lli)
535 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200536
Willy Tarreauf2cb1692019-07-11 10:08:31 +0200537 /* check that another thread didn't to the job in parallel (e.g. at the
538 * end of listen_accept() while we'd come from dequeue_all_listeners().
539 */
Willy Tarreau2b718102021-04-21 07:32:39 +0200540 if (MT_LIST_INLIST(&l->wait_queue))
Willy Tarreauf2cb1692019-07-11 10:08:31 +0200541 goto end;
542
William Lallemand095ba4c2017-06-01 17:38:50 +0200543 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau818a92e2020-09-03 07:50:19 +0200544 !(proc_mask(l->rx.settings->bind_proc) & pid_bit))
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200545 goto end;
Willy Tarreau3569df32017-03-15 12:47:46 +0100546
Aurelien DARRAGON3b78de12023-02-14 08:51:14 +0100547 if (!(l->flags & LI_F_FINALIZED) || l->state == LI_READY)
Willy Tarreau5d7f9ce2020-09-24 18:54:11 +0200548 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200549
Aurelien DARRAGON4713adc2023-02-07 13:26:14 +0100550 if (l->rx.proto->resume) {
Willy Tarreaue03204c2020-10-09 17:02:21 +0200551 ret = l->rx.proto->resume(l);
Aurelien DARRAGON4713adc2023-02-07 13:26:14 +0100552 if (!ret)
553 goto end; /* failure to resume */
554 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200555
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100556 if (l->maxconn && l->nbconn >= l->maxconn) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200557 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200558 listener_set_state(l, LI_FULL);
Willy Tarreau58651b42020-09-24 16:03:29 +0200559 goto done;
Willy Tarreaube58c382011-07-24 18:28:10 +0200560 }
561
Willy Tarreau4b51f422020-09-25 20:32:28 +0200562 l->rx.proto->enable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200563 listener_set_state(l, LI_READY);
Willy Tarreau58651b42020-09-24 16:03:29 +0200564
565 done:
Aurelien DARRAGON8283d592023-02-13 17:45:08 +0100566 if (px && (l->flags & LI_F_SUSPENDED))
567 px->li_suspended--;
568 l->flags &= ~LI_F_SUSPENDED;
569
Aurelien DARRAGON77419282023-02-07 12:36:27 +0100570 if (px && !px->li_suspended) {
Willy Tarreau58651b42020-09-24 16:03:29 +0200571 ha_warning("Resumed %s %s.\n", proxy_cap_str(px->cap), px->id);
572 send_log(px, LOG_WARNING, "Resumed %s %s.\n", proxy_cap_str(px->cap), px->id);
573 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200574 end:
Aurelien DARRAGON7e2eee02023-02-06 17:06:03 +0100575 if (!lli)
576 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200577
Aurelien DARRAGON15c43862022-09-12 09:26:21 +0200578 if (!lpx && px)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200579 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &px->lock);
580
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200581 return ret;
582}
583
Aurelien DARRAGON3e931a42023-02-15 09:30:54 +0100584/* Same as resume_listener(), but will only work to resume from
585 * LI_FULL or LI_LIMITED states because we try to relax listeners that
586 * were temporarily restricted and not to resume inactive listeners that
587 * may have been paused or completely stopped in the meantime.
588 * Returns positive value for success and 0 for failure.
589 * It will need to operate under the proxy's lock and the listener's lock.
590 * The caller is responsible for indicating in lpx, lli whether the respective
591 * locks are already held (non-zero) or not (zero) so that the function pick
592 * the missing ones, in this order.
593 */
594int relax_listener(struct listener *l, int lpx, int lli)
595{
596 int ret = 1;
597
598 if (!lli)
599 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
600
601 if (l->state != LI_FULL && l->state != LI_LIMITED)
602 goto end; /* listener may be suspended or even stopped */
603 ret = resume_listener(l, lpx, 1);
604
605 end:
606 if (!lli)
607 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
608 return ret;
609}
610
Willy Tarreau87b09662015-04-03 00:22:06 +0200611/* Marks a ready listener as full so that the stream code tries to re-enable
Aurelien DARRAGONb1918b12023-02-06 17:19:58 +0100612 * it upon next close() using relax_listener().
Willy Tarreau62793712011-07-24 19:23:38 +0200613 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200614static void listener_full(struct listener *l)
Willy Tarreau62793712011-07-24 19:23:38 +0200615{
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100616 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200617 if (l->state >= LI_READY) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200618 MT_LIST_DELETE(&l->wait_queue);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100619 if (l->state != LI_FULL) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200620 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200621 listener_set_state(l, LI_FULL);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100622 }
Willy Tarreau62793712011-07-24 19:23:38 +0200623 }
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100624 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200625}
626
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200627/* Marks a ready listener as limited so that we only try to re-enable it when
628 * resources are free again. It will be queued into the specified queue.
629 */
Olivier Houchard859dc802019-08-08 15:47:21 +0200630static void limit_listener(struct listener *l, struct mt_list *list)
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200631{
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100632 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200633 if (l->state == LI_READY) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200634 MT_LIST_TRY_APPEND(list, &l->wait_queue);
Willy Tarreau4b51f422020-09-25 20:32:28 +0200635 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200636 listener_set_state(l, LI_LIMITED);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200637 }
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100638 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200639}
640
Willy Tarreau241797a2019-12-10 14:10:52 +0100641/* Dequeues all listeners waiting for a resource the global wait queue */
642void dequeue_all_listeners()
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200643{
Willy Tarreau01abd022019-02-28 10:27:18 +0100644 struct listener *listener;
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200645
Willy Tarreau241797a2019-12-10 14:10:52 +0100646 while ((listener = MT_LIST_POP(&global_listener_queue, struct listener *, wait_queue))) {
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200647 /* This cannot fail because the listeners are by definition in
Willy Tarreau01abd022019-02-28 10:27:18 +0100648 * the LI_LIMITED state.
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200649 */
Aurelien DARRAGONb1918b12023-02-06 17:19:58 +0100650 relax_listener(listener, 0, 0);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200651 }
652}
653
Willy Tarreau241797a2019-12-10 14:10:52 +0100654/* Dequeues all listeners waiting for a resource in proxy <px>'s queue */
655void dequeue_proxy_listeners(struct proxy *px)
656{
657 struct listener *listener;
658
659 while ((listener = MT_LIST_POP(&px->listener_queue, struct listener *, wait_queue))) {
660 /* This cannot fail because the listeners are by definition in
661 * the LI_LIMITED state.
662 */
Aurelien DARRAGONb1918b12023-02-06 17:19:58 +0100663 relax_listener(listener, 0, 0);
Willy Tarreau241797a2019-12-10 14:10:52 +0100664 }
665}
666
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200667
668/* default function used to unbind a listener. This is for use by standard
669 * protocols working on top of accepted sockets. The receiver's rx_unbind()
670 * will automatically be used after the listener is disabled if the socket is
671 * still bound. This must be used under the listener's lock.
Christopher Faulet510c0d62018-03-16 10:04:47 +0100672 */
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200673void default_unbind_listener(struct listener *listener)
Willy Tarreaub648d632007-10-28 22:13:50 +0100674{
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200675 if (listener->state <= LI_ASSIGNED)
676 goto out_close;
677
678 if (listener->rx.fd == -1) {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200679 listener_set_state(listener, LI_ASSIGNED);
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200680 goto out_close;
681 }
682
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200683 if (listener->state >= LI_READY) {
684 listener->rx.proto->disable(listener);
685 if (listener->rx.flags & RX_F_BOUND)
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200686 listener_set_state(listener, LI_LISTEN);
Willy Tarreaub6607bf2020-09-23 16:24:23 +0200687 }
688
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200689 out_close:
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200690 if (listener->rx.flags & RX_F_BOUND)
691 listener->rx.proto->rx_unbind(&listener->rx);
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200692}
693
694/* This function closes the listening socket for the specified listener,
695 * provided that it's already in a listening state. The protocol's unbind()
696 * is called to put the listener into LI_ASSIGNED or LI_LISTEN and handle
697 * the unbinding tasks. The listener enters then the LI_ASSIGNED state if
698 * the receiver is unbound. Must be called with the lock held.
699 */
700void do_unbind_listener(struct listener *listener)
701{
Willy Tarreau2b718102021-04-21 07:32:39 +0200702 MT_LIST_DELETE(&listener->wait_queue);
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200703
704 if (listener->rx.proto->unbind)
705 listener->rx.proto->unbind(listener);
Willy Tarreau374e9af2020-10-09 15:47:17 +0200706
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200707 /* we may have to downgrade the listener if the rx was closed */
708 if (!(listener->rx.flags & RX_F_BOUND) && listener->state > LI_ASSIGNED)
Willy Tarreau374e9af2020-10-09 15:47:17 +0200709 listener_set_state(listener, LI_ASSIGNED);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100710}
711
Olivier Houchard1fc05162017-04-06 01:05:05 +0200712/* This function closes the listening socket for the specified listener,
713 * provided that it's already in a listening state. The listener enters the
Willy Tarreau75c98d12020-10-09 15:55:23 +0200714 * LI_ASSIGNED state, except if the FD is not closed, in which case it may
715 * remain in LI_LISTEN. This function is intended to be used as a generic
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100716 * function for standard protocols.
Olivier Houchard1fc05162017-04-06 01:05:05 +0200717 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100718void unbind_listener(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200719{
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100720 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau75c98d12020-10-09 15:55:23 +0200721 do_unbind_listener(listener);
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100722 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200723}
724
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200725/* creates one or multiple listeners for bind_conf <bc> on sockaddr <ss> on port
726 * range <portl> to <porth>, and possibly attached to fd <fd> (or -1 for auto
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200727 * allocation). The address family is taken from ss->ss_family, and the protocol
Willy Tarreaud2fb99f2020-10-15 21:22:29 +0200728 * passed in <proto> must be usable on this family. The protocol's default iocb
729 * is automatically preset as the receivers' iocb. The number of jobs and
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200730 * listeners is automatically increased by the number of listeners created. It
731 * returns non-zero on success, zero on error with the error message set in <err>.
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200732 */
733int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200734 int portl, int porth, int fd, struct protocol *proto, char **err)
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200735{
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200736 struct listener *l;
737 int port;
738
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200739 for (port = portl; port <= porth; port++) {
740 l = calloc(1, sizeof(*l));
741 if (!l) {
742 memprintf(err, "out of memory");
743 return 0;
744 }
745 l->obj_type = OBJ_TYPE_LISTENER;
Willy Tarreau2b718102021-04-21 07:32:39 +0200746 LIST_APPEND(&bc->frontend->conf.listeners, &l->by_fe);
747 LIST_APPEND(&bc->listeners, &l->by_bind);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200748 l->bind_conf = bc;
Willy Tarreau0fce6bc2020-09-03 07:46:06 +0200749 l->rx.settings = &bc->settings;
Willy Tarreaueef45422020-09-03 10:05:03 +0200750 l->rx.owner = l;
Willy Tarreaud2fb99f2020-10-15 21:22:29 +0200751 l->rx.iocb = proto->default_iocb;
Willy Tarreau38ba6472020-08-27 08:16:52 +0200752 l->rx.fd = fd;
Willy Tarreau07400c52020-12-04 14:49:11 +0100753
Willy Tarreau37159062020-08-27 07:48:42 +0200754 memcpy(&l->rx.addr, ss, sizeof(*ss));
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100755 if (proto->fam->set_port)
756 proto->fam->set_port(&l->rx.addr, port);
Willy Tarreau07400c52020-12-04 14:49:11 +0100757
Olivier Houchard859dc802019-08-08 15:47:21 +0200758 MT_LIST_INIT(&l->wait_queue);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200759 listener_set_state(l, LI_INIT);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200760
Willy Tarreaud1f250f2020-12-04 15:03:36 +0100761 proto->add(proto, l);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200762
Willy Tarreau909c23b2020-09-15 13:50:58 +0200763 if (fd != -1)
Willy Tarreau43046fa2020-09-01 15:41:59 +0200764 l->rx.flags |= RX_F_INHERITED;
William Lallemand75ea0a02017-11-15 19:02:58 +0100765
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +0100766 l->extra_counters = NULL;
767
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100768 HA_RWLOCK_INIT(&l->lock);
Willy Tarreau4781b152021-04-06 13:53:36 +0200769 _HA_ATOMIC_INC(&jobs);
770 _HA_ATOMIC_INC(&listeners);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200771 }
772 return 1;
773}
774
Willy Tarreau1a64d162007-10-28 22:26:05 +0100775/* Delete a listener from its protocol's list of listeners. The listener's
776 * state is automatically updated from LI_ASSIGNED to LI_INIT. The protocol's
Willy Tarreau2cc5bae2017-09-15 08:18:11 +0200777 * number of listeners is updated, as well as the global number of listeners
778 * and jobs. Note that the listener must have previously been unbound. This
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200779 * is a low-level function expected to be called with the proto_lock and the
780 * listener's lock held.
Willy Tarreau1a64d162007-10-28 22:26:05 +0100781 */
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200782void __delete_listener(struct listener *listener)
Willy Tarreau1a64d162007-10-28 22:26:05 +0100783{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100784 if (listener->state == LI_ASSIGNED) {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200785 listener_set_state(listener, LI_INIT);
Willy Tarreau2b718102021-04-21 07:32:39 +0200786 LIST_DELETE(&listener->rx.proto_list);
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200787 listener->rx.proto->nb_receivers--;
Willy Tarreau4781b152021-04-06 13:53:36 +0200788 _HA_ATOMIC_DEC(&jobs);
789 _HA_ATOMIC_DEC(&listeners);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100790 }
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200791}
792
793/* Delete a listener from its protocol's list of listeners (please check
794 * __delete_listener() above). The proto_lock and the listener's lock will
795 * be grabbed in this order.
796 */
797void delete_listener(struct listener *listener)
798{
799 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100800 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200801 __delete_listener(listener);
Willy Tarreauae3f22f2022-02-01 16:23:00 +0100802 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau6ee9f8d2019-08-26 10:55:52 +0200803 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau1a64d162007-10-28 22:26:05 +0100804}
805
Willy Tarreaue2711c72019-02-27 15:39:41 +0100806/* Returns a suitable value for a listener's backlog. It uses the listener's,
807 * otherwise the frontend's backlog, otherwise the listener's maxconn,
808 * otherwise the frontend's maxconn, otherwise 1024.
809 */
810int listener_backlog(const struct listener *l)
811{
812 if (l->backlog)
813 return l->backlog;
814
815 if (l->bind_conf->frontend->backlog)
816 return l->bind_conf->frontend->backlog;
817
818 if (l->maxconn)
819 return l->maxconn;
820
821 if (l->bind_conf->frontend->maxconn)
822 return l->bind_conf->frontend->maxconn;
823
824 return 1024;
825}
826
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200827/* This function is called on a read event from a listening socket, corresponding
828 * to an accept. It tries to accept as many connections as possible, and for each
829 * calls the listener's accept handler (generally the frontend's accept handler).
830 */
Willy Tarreaua74cb382020-10-15 21:29:49 +0200831void listener_accept(struct listener *l)
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200832{
Willy Tarreau83efc322020-10-14 17:37:17 +0200833 struct connection *cli_conn;
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100834 struct proxy *p;
Christopher Faulet102854c2019-04-30 12:17:13 +0200835 unsigned int max_accept;
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100836 int next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100837 int next_feconn = 0;
838 int next_actconn = 0;
Willy Tarreaubb660302014-05-07 19:47:02 +0200839 int expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200840 int ret;
841
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100842 p = l->bind_conf->frontend;
Christopher Faulet102854c2019-04-30 12:17:13 +0200843
844 /* if l->maxaccept is -1, then max_accept is UINT_MAX. It is not really
845 * illimited, but it is probably enough.
846 */
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100847 max_accept = l->maxaccept ? l->maxaccept : 1;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200848
Willy Tarreau93e7c002013-10-07 18:51:07 +0200849 if (!(l->options & LI_O_UNLIMITED) && global.sps_lim) {
850 int max = freq_ctr_remain(&global.sess_per_sec, global.sps_lim, 0);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200851
852 if (unlikely(!max)) {
853 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200854 expire = tick_add(now_ms, next_event_delay(&global.sess_per_sec, global.sps_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100855 goto limit_global;
Willy Tarreau93e7c002013-10-07 18:51:07 +0200856 }
857
858 if (max_accept > max)
859 max_accept = max;
860 }
861
862 if (!(l->options & LI_O_UNLIMITED) && global.cps_lim) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200863 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
864
865 if (unlikely(!max)) {
866 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200867 expire = tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100868 goto limit_global;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200869 }
870
871 if (max_accept > max)
872 max_accept = max;
873 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200874#ifdef USE_OPENSSL
875 if (!(l->options & LI_O_UNLIMITED) && global.ssl_lim && l->bind_conf && l->bind_conf->is_ssl) {
876 int max = freq_ctr_remain(&global.ssl_per_sec, global.ssl_lim, 0);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200877
Willy Tarreaue43d5322013-10-07 20:01:52 +0200878 if (unlikely(!max)) {
879 /* frontend accept rate limit was reached */
Willy Tarreaue43d5322013-10-07 20:01:52 +0200880 expire = tick_add(now_ms, next_event_delay(&global.ssl_per_sec, global.ssl_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100881 goto limit_global;
Willy Tarreaue43d5322013-10-07 20:01:52 +0200882 }
883
884 if (max_accept > max)
885 max_accept = max;
886 }
887#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200888 if (p && p->fe_sps_lim) {
889 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
890
891 if (unlikely(!max)) {
892 /* frontend accept rate limit was reached */
Willy Tarreau0591bf72019-12-10 12:01:21 +0100893 expire = tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0));
894 goto limit_proxy;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200895 }
896
897 if (max_accept > max)
898 max_accept = max;
899 }
900
901 /* Note: if we fail to allocate a connection because of configured
902 * limits, we'll schedule a new attempt worst 1 second later in the
903 * worst case. If we fail due to system limits or temporary resource
904 * shortage, we try again 100ms later in the worst case.
905 */
Willy Tarreau02757d02021-01-28 18:07:24 +0100906 for (; max_accept; next_conn = next_feconn = next_actconn = 0, max_accept--) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200907 unsigned int count;
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200908 int status;
Willy Tarreau0aa5a5b2020-10-16 17:43:04 +0200909 __decl_thread(unsigned long mask);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200910
Willy Tarreau82c97892019-02-27 19:32:32 +0100911 /* pre-increase the number of connections without going too far.
912 * We process the listener, then the proxy, then the process.
913 * We know which ones to unroll based on the next_xxx value.
914 */
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100915 do {
916 count = l->nbconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100917 if (unlikely(l->maxconn && count >= l->maxconn)) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100918 /* the listener was marked full or another
919 * thread is going to do it.
920 */
921 next_conn = 0;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100922 listener_full(l);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100923 goto end;
924 }
925 next_conn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000926 } while (!_HA_ATOMIC_CAS(&l->nbconn, (int *)(&count), next_conn));
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100927
Willy Tarreau82c97892019-02-27 19:32:32 +0100928 if (p) {
929 do {
930 count = p->feconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100931 if (unlikely(count >= p->maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100932 /* the frontend was marked full or another
933 * thread is going to do it.
934 */
935 next_feconn = 0;
Willy Tarreau0591bf72019-12-10 12:01:21 +0100936 expire = TICK_ETERNITY;
937 goto limit_proxy;
Willy Tarreau82c97892019-02-27 19:32:32 +0100938 }
939 next_feconn = count + 1;
Olivier Houchard64213e92019-03-08 18:52:57 +0100940 } while (!_HA_ATOMIC_CAS(&p->feconn, &count, next_feconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200941 }
942
Willy Tarreau82c97892019-02-27 19:32:32 +0100943 if (!(l->options & LI_O_UNLIMITED)) {
944 do {
945 count = actconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100946 if (unlikely(count >= global.maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100947 /* the process was marked full or another
948 * thread is going to do it.
949 */
950 next_actconn = 0;
Willy Tarreau0591bf72019-12-10 12:01:21 +0100951 expire = tick_add(now_ms, 1000); /* try again in 1 second */
952 goto limit_global;
Willy Tarreau82c97892019-02-27 19:32:32 +0100953 }
954 next_actconn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000955 } while (!_HA_ATOMIC_CAS(&actconn, (int *)(&count), next_actconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200956 }
957
Willy Tarreaud276ee52022-02-01 16:37:00 +0100958 /* be careful below, the listener might be shutting down in
959 * another thread on error and we must not dereference its
960 * FD without a bit of protection.
961 */
962 cli_conn = NULL;
963 status = CO_AC_PERMERR;
964
965 HA_RWLOCK_RDLOCK(LISTENER_LOCK, &l->lock);
966 if (l->rx.flags & RX_F_BOUND)
967 cli_conn = l->rx.proto->accept_conn(l, &status);
968 HA_RWLOCK_RDUNLOCK(LISTENER_LOCK, &l->lock);
969
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200970 if (!cli_conn) {
971 switch (status) {
972 case CO_AC_DONE:
973 goto end;
Willy Tarreau818dca52014-01-31 19:40:19 +0100974
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200975 case CO_AC_RETRY: /* likely a signal */
Willy Tarreau4781b152021-04-06 13:53:36 +0200976 _HA_ATOMIC_DEC(&l->nbconn);
Willy Tarreau82c97892019-02-27 19:32:32 +0100977 if (p)
Willy Tarreau4781b152021-04-06 13:53:36 +0200978 _HA_ATOMIC_DEC(&p->feconn);
Willy Tarreau82c97892019-02-27 19:32:32 +0100979 if (!(l->options & LI_O_UNLIMITED))
Willy Tarreau4781b152021-04-06 13:53:36 +0200980 _HA_ATOMIC_DEC(&actconn);
Willy Tarreaua593ec52014-01-20 21:21:30 +0100981 continue;
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200982
983 case CO_AC_YIELD:
Willy Tarreau92079932019-12-10 09:30:05 +0100984 max_accept = 0;
985 goto end;
William Lallemandd9138002018-11-27 12:02:39 +0100986
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200987 default:
988 goto transient_error;
Willy Tarreau83efc322020-10-14 17:37:17 +0200989 }
990 }
991
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100992 /* The connection was accepted, it must be counted as such */
993 if (l->counters)
994 HA_ATOMIC_UPDATE_MAX(&l->counters->conn_max, next_conn);
995
Willy Tarreauee3ec402022-05-09 20:41:54 +0200996 if (p) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100997 HA_ATOMIC_UPDATE_MAX(&p->fe_counters.conn_max, next_feconn);
Willy Tarreauee3ec402022-05-09 20:41:54 +0200998 proxy_inc_fe_conn_ctr(l, p);
999 }
Willy Tarreau82c97892019-02-27 19:32:32 +01001000
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001001 if (!(l->options & LI_O_UNLIMITED)) {
1002 count = update_freq_ctr(&global.conn_per_sec, 1);
1003 HA_ATOMIC_UPDATE_MAX(&global.cps_max, count);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001004 }
1005
Willy Tarreau4781b152021-04-06 13:53:36 +02001006 _HA_ATOMIC_INC(&activity[tid].accepted);
Willy Tarreau64a9c052019-04-12 15:27:17 +02001007
Willy Tarreau9378bbe2020-10-15 10:09:31 +02001008 if (unlikely(cli_conn->handle.fd >= global.maxsock)) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001009 send_log(p, LOG_EMERG,
1010 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
1011 p->id);
Willy Tarreau9378bbe2020-10-15 10:09:31 +02001012 close(cli_conn->handle.fd);
William Dauchy835712a2020-10-18 18:37:43 +02001013 conn_free(cli_conn);
Willy Tarreau0591bf72019-12-10 12:01:21 +01001014 expire = tick_add(now_ms, 1000); /* try again in 1 second */
1015 goto limit_global;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001016 }
1017
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001018 /* past this point, l->accept() will automatically decrement
Willy Tarreau82c97892019-02-27 19:32:32 +01001019 * l->nbconn, feconn and actconn once done. Setting next_*conn=0
1020 * allows the error path not to rollback on nbconn. It's more
1021 * convenient than duplicating all exit labels.
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001022 */
1023 next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +01001024 next_feconn = 0;
1025 next_actconn = 0;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001026
Willy Tarreau83efc322020-10-14 17:37:17 +02001027
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001028#if defined(USE_THREAD)
Willy Tarreau818a92e2020-09-03 07:50:19 +02001029 mask = thread_mask(l->rx.settings->bind_thread) & all_threads_mask;
Willy Tarreaua7da5e82020-03-12 17:33:29 +01001030 if (atleast2(mask) && (global.tune.options & GTUNE_LISTENER_MQ) && !stopping) {
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001031 struct accept_queue_ring *ring;
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001032 unsigned int t, t0, t1, t2;
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001033
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001034 /* The principle is that we have two running indexes,
1035 * each visiting in turn all threads bound to this
1036 * listener. The connection will be assigned to the one
1037 * with the least connections, and the other one will
1038 * be updated. This provides a good fairness on short
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001039 * connections (round robin) and on long ones (conn
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001040 * count), without ever missing any idle thread.
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001041 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001042
1043 /* keep a copy for the final update. thr_idx is composite
1044 * and made of (t2<<16) + t1.
1045 */
Willy Tarreau0cf33172019-03-06 15:26:33 +01001046 t0 = l->thr_idx;
Willy Tarreaufc630bd2019-03-04 19:57:34 +01001047 do {
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001048 unsigned long m1, m2;
1049 int q1, q2;
1050
1051 t2 = t1 = t0;
1052 t2 >>= 16;
1053 t1 &= 0xFFFF;
1054
1055 /* t1 walks low to high bits ;
1056 * t2 walks high to low.
1057 */
1058 m1 = mask >> t1;
1059 m2 = mask & (t2 ? nbits(t2 + 1) : ~0UL);
1060
Willy Tarreau85d04242019-04-16 18:09:13 +02001061 if (unlikely(!(m1 & 1))) {
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001062 m1 &= ~1UL;
1063 if (!m1) {
1064 m1 = mask;
1065 t1 = 0;
1066 }
1067 t1 += my_ffsl(m1) - 1;
1068 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001069
Willy Tarreau85d04242019-04-16 18:09:13 +02001070 if (unlikely(!(m2 & (1UL << t2)) || t1 == t2)) {
1071 /* highest bit not set */
1072 if (!m2)
1073 m2 = mask;
1074
1075 t2 = my_flsl(m2) - 1;
1076 }
1077
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001078 /* now we have two distinct thread IDs belonging to the mask */
1079 q1 = accept_queue_rings[t1].tail - accept_queue_rings[t1].head + ACCEPT_QUEUE_SIZE;
1080 if (q1 >= ACCEPT_QUEUE_SIZE)
1081 q1 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001082
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001083 q2 = accept_queue_rings[t2].tail - accept_queue_rings[t2].head + ACCEPT_QUEUE_SIZE;
1084 if (q2 >= ACCEPT_QUEUE_SIZE)
1085 q2 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001086
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001087 /* we have 3 possibilities now :
1088 * q1 < q2 : t1 is less loaded than t2, so we pick it
1089 * and update t2 (since t1 might still be
1090 * lower than another thread)
1091 * q1 > q2 : t2 is less loaded than t1, so we pick it
1092 * and update t1 (since t2 might still be
1093 * lower than another thread)
1094 * q1 = q2 : both are equally loaded, thus we pick t1
1095 * and update t1 as it will become more loaded
1096 * than t2.
1097 */
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001098
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001099 q1 += l->thr_conn[t1];
1100 q2 += l->thr_conn[t2];
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001101
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001102 if (q1 - q2 < 0) {
1103 t = t1;
1104 t2 = t2 ? t2 - 1 : LONGBITS - 1;
1105 }
1106 else if (q1 - q2 > 0) {
1107 t = t2;
1108 t1++;
1109 if (t1 >= LONGBITS)
1110 t1 = 0;
1111 }
1112 else {
1113 t = t1;
1114 t1++;
1115 if (t1 >= LONGBITS)
1116 t1 = 0;
1117 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001118
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001119 /* new value for thr_idx */
1120 t1 += (t2 << 16);
Olivier Houchard64213e92019-03-08 18:52:57 +01001121 } while (unlikely(!_HA_ATOMIC_CAS(&l->thr_idx, &t0, t1)));
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001122
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001123 /* We successfully selected the best thread "t" for this
1124 * connection. We use deferred accepts even if it's the
1125 * local thread because tests show that it's the best
1126 * performing model, likely due to better cache locality
1127 * when processing this loop.
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001128 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +01001129 ring = &accept_queue_rings[t];
Willy Tarreau83efc322020-10-14 17:37:17 +02001130 if (accept_queue_push_mp(ring, cli_conn)) {
Willy Tarreau4781b152021-04-06 13:53:36 +02001131 _HA_ATOMIC_INC(&activity[t].accq_pushed);
Willy Tarreau2bd65a72019-09-24 06:55:18 +02001132 tasklet_wakeup(ring->tasklet);
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001133 continue;
1134 }
1135 /* If the ring is full we do a synchronous accept on
1136 * the local thread here.
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001137 */
Willy Tarreau4781b152021-04-06 13:53:36 +02001138 _HA_ATOMIC_INC(&activity[t].accq_full);
Willy Tarreaue0e9c482019-01-27 15:37:19 +01001139 }
1140#endif // USE_THREAD
1141
Willy Tarreau4781b152021-04-06 13:53:36 +02001142 _HA_ATOMIC_INC(&l->thr_conn[tid]);
Willy Tarreau83efc322020-10-14 17:37:17 +02001143 ret = l->accept(cli_conn);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001144 if (unlikely(ret <= 0)) {
Willy Tarreau87b09662015-04-03 00:22:06 +02001145 /* The connection was closed by stream_accept(). Either
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001146 * we just have to ignore it (ret == 0) or it's a critical
1147 * error due to a resource shortage, and we must stop the
1148 * listener (ret < 0).
1149 */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001150 if (ret == 0) /* successful termination */
1151 continue;
1152
Willy Tarreaubb660302014-05-07 19:47:02 +02001153 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001154 }
1155
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001156 /* increase the per-process number of cumulated sessions, this
1157 * may only be done once l->accept() has accepted the connection.
1158 */
Willy Tarreau93e7c002013-10-07 18:51:07 +02001159 if (!(l->options & LI_O_UNLIMITED)) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001160 count = update_freq_ctr(&global.sess_per_sec, 1);
1161 HA_ATOMIC_UPDATE_MAX(&global.sps_max, count);
Willy Tarreau93e7c002013-10-07 18:51:07 +02001162 }
Willy Tarreaue43d5322013-10-07 20:01:52 +02001163#ifdef USE_OPENSSL
1164 if (!(l->options & LI_O_UNLIMITED) && l->bind_conf && l->bind_conf->is_ssl) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001165 count = update_freq_ctr(&global.ssl_per_sec, 1);
1166 HA_ATOMIC_UPDATE_MAX(&global.ssl_max, count);
Willy Tarreaue43d5322013-10-07 20:01:52 +02001167 }
1168#endif
Willy Tarreau93e7c002013-10-07 18:51:07 +02001169
Willy Tarreau8d2c98b2020-05-01 09:51:11 +02001170 ti->flags &= ~TI_FL_STUCK; // this thread is still running
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001171 } /* end of for (max_accept--) */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001172
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001173 end:
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001174 if (next_conn)
Willy Tarreau4781b152021-04-06 13:53:36 +02001175 _HA_ATOMIC_DEC(&l->nbconn);
Willy Tarreau741b4d62019-02-25 15:02:04 +01001176
Willy Tarreau82c97892019-02-27 19:32:32 +01001177 if (p && next_feconn)
Willy Tarreau4781b152021-04-06 13:53:36 +02001178 _HA_ATOMIC_DEC(&p->feconn);
Willy Tarreau82c97892019-02-27 19:32:32 +01001179
1180 if (next_actconn)
Willy Tarreau4781b152021-04-06 13:53:36 +02001181 _HA_ATOMIC_DEC(&actconn);
Willy Tarreau82c97892019-02-27 19:32:32 +01001182
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001183 if ((l->state == LI_FULL && (!l->maxconn || l->nbconn < l->maxconn)) ||
Willy Tarreau02757d02021-01-28 18:07:24 +01001184 (l->state == LI_LIMITED &&
Willy Tarreaucdcba112019-12-11 15:06:30 +01001185 ((!p || p->feconn < p->maxconn) && (actconn < global.maxconn) &&
1186 (!tick_isset(global_listener_queue_task->expire) ||
1187 tick_is_expired(global_listener_queue_task->expire, now_ms))))) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001188 /* at least one thread has to this when quitting */
Aurelien DARRAGONb1918b12023-02-06 17:19:58 +01001189 relax_listener(l, 0, 0);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001190
Willy Tarreau02757d02021-01-28 18:07:24 +01001191 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001192 dequeue_all_listeners();
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001193
Olivier Houchard859dc802019-08-08 15:47:21 +02001194 if (p && !MT_LIST_ISEMPTY(&p->listener_queue) &&
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001195 (!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 +01001196 dequeue_proxy_listeners(p);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001197 }
Willy Tarreau0591bf72019-12-10 12:01:21 +01001198 return;
1199
1200 transient_error:
1201 /* pause the listener for up to 100 ms */
1202 expire = tick_add(now_ms, 100);
1203
Willy Tarreau258b3512020-10-13 17:46:05 +02001204 /* This may be a shared socket that was paused by another process.
1205 * Let's put it to pause in this case.
1206 */
1207 if (l->rx.proto && l->rx.proto->rx_listening(&l->rx) == 0) {
Aurelien DARRAGON8283d592023-02-13 17:45:08 +01001208 suspend_listener(l, 0, 0);
Willy Tarreau258b3512020-10-13 17:46:05 +02001209 goto end;
1210 }
1211
Willy Tarreau0591bf72019-12-10 12:01:21 +01001212 limit_global:
1213 /* (re-)queue the listener to the global queue and set it to expire no
1214 * later than <expire> ahead. The listener turns to LI_LIMITED.
1215 */
1216 limit_listener(l, &global_listener_queue);
Christopher Faulete088fb32022-11-17 14:40:20 +01001217 HA_RWLOCK_RDLOCK(LISTENER_LOCK, &global_listener_rwlock);
Willy Tarreau0591bf72019-12-10 12:01:21 +01001218 task_schedule(global_listener_queue_task, expire);
Christopher Faulete088fb32022-11-17 14:40:20 +01001219 HA_RWLOCK_RDUNLOCK(LISTENER_LOCK, &global_listener_rwlock);
Willy Tarreau0591bf72019-12-10 12:01:21 +01001220 goto end;
1221
1222 limit_proxy:
1223 /* (re-)queue the listener to the proxy's queue and set it to expire no
1224 * later than <expire> ahead. The listener turns to LI_LIMITED.
1225 */
1226 limit_listener(l, &p->listener_queue);
Willy Tarreaueeea8082020-01-08 19:15:07 +01001227 if (p->task && tick_isset(expire))
1228 task_schedule(p->task, expire);
Willy Tarreau0591bf72019-12-10 12:01:21 +01001229 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001230}
1231
Willy Tarreau05f50472017-09-15 09:19:58 +02001232/* Notify the listener that a connection initiated from it was released. This
1233 * is used to keep the connection count consistent and to possibly re-open
1234 * listening when it was limited.
1235 */
1236void listener_release(struct listener *l)
1237{
1238 struct proxy *fe = l->bind_conf->frontend;
1239
1240 if (!(l->options & LI_O_UNLIMITED))
Willy Tarreau4781b152021-04-06 13:53:36 +02001241 _HA_ATOMIC_DEC(&actconn);
Willy Tarreau82c97892019-02-27 19:32:32 +01001242 if (fe)
Willy Tarreau4781b152021-04-06 13:53:36 +02001243 _HA_ATOMIC_DEC(&fe->feconn);
1244 _HA_ATOMIC_DEC(&l->nbconn);
1245 _HA_ATOMIC_DEC(&l->thr_conn[tid]);
Willy Tarreau82c97892019-02-27 19:32:32 +01001246
1247 if (l->state == LI_FULL || l->state == LI_LIMITED)
Aurelien DARRAGONb1918b12023-02-06 17:19:58 +01001248 relax_listener(l, 0, 0);
Willy Tarreau05f50472017-09-15 09:19:58 +02001249
Willy Tarreau02757d02021-01-28 18:07:24 +01001250 /* Dequeues all of the listeners waiting for a resource */
1251 dequeue_all_listeners();
1252
Aurelien DARRAGON15c43862022-09-12 09:26:21 +02001253 if (fe && !MT_LIST_ISEMPTY(&fe->listener_queue) &&
Willy Tarreau05f50472017-09-15 09:19:58 +02001254 (!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 +01001255 dequeue_proxy_listeners(fe);
Willy Tarreau05f50472017-09-15 09:19:58 +02001256}
1257
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001258/* Initializes the listener queues. Returns 0 on success, otherwise ERR_* flags */
1259static int listener_queue_init()
1260{
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001261 global_listener_queue_task = task_new(MAX_THREADS_MASK);
1262 if (!global_listener_queue_task) {
1263 ha_alert("Out of memory when initializing global listener queue\n");
1264 return ERR_FATAL|ERR_ABORT;
1265 }
1266 /* very simple initialization, users will queue the task if needed */
1267 global_listener_queue_task->context = NULL; /* not even a context! */
1268 global_listener_queue_task->process = manage_global_listener_queue;
Christopher Faulete088fb32022-11-17 14:40:20 +01001269 HA_RWLOCK_INIT(&global_listener_rwlock);
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001270
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001271 return 0;
1272}
1273
1274static void listener_queue_deinit()
1275{
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001276 task_destroy(global_listener_queue_task);
1277 global_listener_queue_task = NULL;
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001278}
1279
1280REGISTER_CONFIG_POSTPARSER("multi-threaded listener queue", listener_queue_init);
1281REGISTER_POST_DEINIT(listener_queue_deinit);
1282
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001283
1284/* This is the global management task for listeners. It enables listeners waiting
1285 * for global resources when there are enough free resource, or at least once in
Willy Tarreaud597ec22021-01-29 14:29:06 +01001286 * a while. It is designed to be called as a task. It's exported so that it's easy
1287 * to spot in "show tasks" or "show profiling".
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001288 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001289struct task *manage_global_listener_queue(struct task *t, void *context, unsigned int state)
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001290{
1291 /* If there are still too many concurrent connections, let's wait for
1292 * some of them to go away. We don't need to re-arm the timer because
1293 * each of them will scan the queue anyway.
1294 */
1295 if (unlikely(actconn >= global.maxconn))
1296 goto out;
1297
1298 /* We should periodically try to enable listeners waiting for a global
1299 * resource here, because it is possible, though very unlikely, that
1300 * they have been blocked by a temporary lack of global resource such
1301 * as a file descriptor or memory and that the temporary condition has
1302 * disappeared.
1303 */
1304 dequeue_all_listeners();
1305
1306 out:
Christopher Faulete088fb32022-11-17 14:40:20 +01001307 HA_RWLOCK_WRLOCK(LISTENER_LOCK, &global_listener_rwlock);
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001308 t->expire = TICK_ETERNITY;
Christopher Faulete088fb32022-11-17 14:40:20 +01001309 HA_RWLOCK_WRUNLOCK(LISTENER_LOCK, &global_listener_rwlock);
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001310 task_queue(t);
1311 return t;
1312}
1313
Willy Tarreau26982662012-09-12 23:17:10 +02001314/*
1315 * Registers the bind keyword list <kwl> as a list of valid keywords for next
1316 * parsing sessions.
1317 */
1318void bind_register_keywords(struct bind_kw_list *kwl)
1319{
Willy Tarreau2b718102021-04-21 07:32:39 +02001320 LIST_APPEND(&bind_keywords.list, &kwl->list);
Willy Tarreau26982662012-09-12 23:17:10 +02001321}
1322
1323/* Return a pointer to the bind keyword <kw>, or NULL if not found. If the
1324 * keyword is found with a NULL ->parse() function, then an attempt is made to
1325 * find one with a valid ->parse() function. This way it is possible to declare
1326 * platform-dependant, known keywords as NULL, then only declare them as valid
1327 * if some options are met. Note that if the requested keyword contains an
1328 * opening parenthesis, everything from this point is ignored.
1329 */
1330struct bind_kw *bind_find_kw(const char *kw)
1331{
1332 int index;
1333 const char *kwend;
1334 struct bind_kw_list *kwl;
1335 struct bind_kw *ret = NULL;
1336
1337 kwend = strchr(kw, '(');
1338 if (!kwend)
1339 kwend = kw + strlen(kw);
1340
1341 list_for_each_entry(kwl, &bind_keywords.list, list) {
1342 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1343 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
1344 kwl->kw[index].kw[kwend-kw] == 0) {
1345 if (kwl->kw[index].parse)
1346 return &kwl->kw[index]; /* found it !*/
1347 else
1348 ret = &kwl->kw[index]; /* may be OK */
1349 }
1350 }
1351 }
1352 return ret;
1353}
1354
Willy Tarreau8638f482012-09-18 18:01:17 +02001355/* Dumps all registered "bind" keywords to the <out> string pointer. The
1356 * unsupported keywords are only dumped if their supported form was not
1357 * found.
1358 */
1359void bind_dump_kws(char **out)
1360{
1361 struct bind_kw_list *kwl;
1362 int index;
1363
Christopher Faulet784063e2020-05-18 12:14:18 +02001364 if (!out)
1365 return;
1366
Willy Tarreau8638f482012-09-18 18:01:17 +02001367 *out = NULL;
1368 list_for_each_entry(kwl, &bind_keywords.list, list) {
1369 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1370 if (kwl->kw[index].parse ||
1371 bind_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
Willy Tarreau51fb7652012-09-18 18:24:39 +02001372 memprintf(out, "%s[%4s] %s%s%s\n", *out ? *out : "",
1373 kwl->scope,
Willy Tarreau8638f482012-09-18 18:01:17 +02001374 kwl->kw[index].kw,
Willy Tarreau51fb7652012-09-18 18:24:39 +02001375 kwl->kw[index].skip ? " <arg>" : "",
1376 kwl->kw[index].parse ? "" : " (not supported)");
Willy Tarreau8638f482012-09-18 18:01:17 +02001377 }
1378 }
1379 }
1380}
1381
Willy Tarreau433b05f2021-03-12 10:14:07 +01001382/* Try to find in srv_keyword the word that looks closest to <word> by counting
1383 * transitions between letters, digits and other characters. Will return the
1384 * best matching word if found, otherwise NULL.
1385 */
1386const char *bind_find_best_kw(const char *word)
1387{
1388 uint8_t word_sig[1024];
1389 uint8_t list_sig[1024];
1390 const struct bind_kw_list *kwl;
1391 const char *best_ptr = NULL;
1392 int dist, best_dist = INT_MAX;
1393 int index;
1394
1395 make_word_fingerprint(word_sig, word);
1396 list_for_each_entry(kwl, &bind_keywords.list, list) {
1397 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1398 make_word_fingerprint(list_sig, kwl->kw[index].kw);
1399 dist = word_fingerprint_distance(word_sig, list_sig);
1400 if (dist < best_dist) {
1401 best_dist = dist;
1402 best_ptr = kwl->kw[index].kw;
1403 }
1404 }
1405 }
1406
1407 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
1408 best_ptr = NULL;
1409
1410 return best_ptr;
1411}
1412
Willy Tarreau645513a2010-05-24 20:55:15 +02001413/************************************************************************/
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001414/* All supported sample and ACL keywords must be declared here. */
Willy Tarreau645513a2010-05-24 20:55:15 +02001415/************************************************************************/
1416
Willy Tarreaua5e37562011-12-16 17:06:15 +01001417/* set temp integer to the number of connexions to the same listening socket */
Willy Tarreau645513a2010-05-24 20:55:15 +02001418static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001419smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau645513a2010-05-24 20:55:15 +02001420{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001421 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001422 smp->data.u.sint = smp->sess->listener->nbconn;
Willy Tarreau645513a2010-05-24 20:55:15 +02001423 return 1;
1424}
1425
Willy Tarreaua5e37562011-12-16 17:06:15 +01001426/* set temp integer to the id of the socket (listener) */
Willy Tarreau645513a2010-05-24 20:55:15 +02001427static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001428smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau37406352012-04-23 16:16:37 +02001429{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001430 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001431 smp->data.u.sint = smp->sess->listener->luid;
Willy Tarreau645513a2010-05-24 20:55:15 +02001432 return 1;
1433}
Jerome Magnineb421b22020-03-27 22:08:40 +01001434static int
1435smp_fetch_so_name(const struct arg *args, struct sample *smp, const char *kw, void *private)
1436{
1437 smp->data.u.str.area = smp->sess->listener->name;
1438 if (!smp->data.u.str.area)
1439 return 0;
1440
1441 smp->data.type = SMP_T_STR;
1442 smp->flags = SMP_F_CONST;
1443 smp->data.u.str.data = strlen(smp->data.u.str.area);
1444 return 1;
1445}
Willy Tarreau645513a2010-05-24 20:55:15 +02001446
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001447/* parse the "accept-proxy" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001448static 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 +02001449{
1450 struct listener *l;
1451
Willy Tarreau4348fad2012-09-20 16:48:07 +02001452 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001453 l->options |= LI_O_ACC_PROXY;
1454
1455 return 0;
1456}
1457
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001458/* parse the "accept-netscaler-cip" bind keyword */
1459static int bind_parse_accept_netscaler_cip(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1460{
1461 struct listener *l;
1462 uint32_t val;
1463
1464 if (!*args[cur_arg + 1]) {
1465 memprintf(err, "'%s' : missing value", args[cur_arg]);
1466 return ERR_ALERT | ERR_FATAL;
1467 }
1468
1469 val = atol(args[cur_arg + 1]);
1470 if (val <= 0) {
Willy Tarreaue2711c72019-02-27 15:39:41 +01001471 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001472 return ERR_ALERT | ERR_FATAL;
1473 }
1474
1475 list_for_each_entry(l, &conf->listeners, by_bind) {
1476 l->options |= LI_O_ACC_CIP;
1477 conf->ns_cip_magic = val;
1478 }
1479
1480 return 0;
1481}
1482
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001483/* parse the "backlog" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001484static 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 +02001485{
1486 struct listener *l;
1487 int val;
1488
1489 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001490 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001491 return ERR_ALERT | ERR_FATAL;
1492 }
1493
1494 val = atol(args[cur_arg + 1]);
Willy Tarreaue2711c72019-02-27 15:39:41 +01001495 if (val < 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001496 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001497 return ERR_ALERT | ERR_FATAL;
1498 }
1499
Willy Tarreau4348fad2012-09-20 16:48:07 +02001500 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001501 l->backlog = val;
1502
1503 return 0;
1504}
1505
1506/* parse the "id" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001507static 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 +02001508{
1509 struct eb32_node *node;
Willy Tarreau4348fad2012-09-20 16:48:07 +02001510 struct listener *l, *new;
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001511 char *error;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001512
Willy Tarreau4348fad2012-09-20 16:48:07 +02001513 if (conf->listeners.n != conf->listeners.p) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001514 memprintf(err, "'%s' can only be used with a single socket", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001515 return ERR_ALERT | ERR_FATAL;
1516 }
1517
1518 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001519 memprintf(err, "'%s' : expects an integer argument", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001520 return ERR_ALERT | ERR_FATAL;
1521 }
1522
Willy Tarreau4348fad2012-09-20 16:48:07 +02001523 new = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001524 new->luid = strtol(args[cur_arg + 1], &error, 10);
1525 if (*error != '\0') {
1526 memprintf(err, "'%s' : expects an integer argument, found '%s'", args[cur_arg], args[cur_arg + 1]);
1527 return ERR_ALERT | ERR_FATAL;
1528 }
Willy Tarreau4348fad2012-09-20 16:48:07 +02001529 new->conf.id.key = new->luid;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001530
Willy Tarreau4348fad2012-09-20 16:48:07 +02001531 if (new->luid <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001532 memprintf(err, "'%s' : custom id has to be > 0", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001533 return ERR_ALERT | ERR_FATAL;
1534 }
1535
Willy Tarreau4348fad2012-09-20 16:48:07 +02001536 node = eb32_lookup(&px->conf.used_listener_id, new->luid);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001537 if (node) {
1538 l = container_of(node, struct listener, conf.id);
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001539 memprintf(err, "'%s' : custom id %d already used at %s:%d ('bind %s')",
1540 args[cur_arg], l->luid, l->bind_conf->file, l->bind_conf->line,
1541 l->bind_conf->arg);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001542 return ERR_ALERT | ERR_FATAL;
1543 }
1544
Willy Tarreau4348fad2012-09-20 16:48:07 +02001545 eb32_insert(&px->conf.used_listener_id, &new->conf.id);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001546 return 0;
1547}
1548
1549/* parse the "maxconn" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001550static 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 +02001551{
1552 struct listener *l;
1553 int val;
1554
1555 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001556 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001557 return ERR_ALERT | ERR_FATAL;
1558 }
1559
1560 val = atol(args[cur_arg + 1]);
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001561 if (val < 0) {
1562 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001563 return ERR_ALERT | ERR_FATAL;
1564 }
1565
Willy Tarreau4348fad2012-09-20 16:48:07 +02001566 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001567 l->maxconn = val;
1568
1569 return 0;
1570}
1571
1572/* parse the "name" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001573static 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 +02001574{
1575 struct listener *l;
1576
1577 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001578 memprintf(err, "'%s' : missing name", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001579 return ERR_ALERT | ERR_FATAL;
1580 }
1581
Willy Tarreau4348fad2012-09-20 16:48:07 +02001582 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001583 l->name = strdup(args[cur_arg + 1]);
1584
1585 return 0;
1586}
1587
1588/* parse the "nice" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001589static 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 +02001590{
1591 struct listener *l;
1592 int val;
1593
1594 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001595 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001596 return ERR_ALERT | ERR_FATAL;
1597 }
1598
1599 val = atol(args[cur_arg + 1]);
1600 if (val < -1024 || val > 1024) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001601 memprintf(err, "'%s' : invalid value %d, allowed range is -1024..1024", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001602 return ERR_ALERT | ERR_FATAL;
1603 }
1604
Willy Tarreau4348fad2012-09-20 16:48:07 +02001605 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001606 l->nice = val;
1607
1608 return 0;
1609}
1610
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001611/* parse the "process" bind keyword */
1612static int bind_parse_process(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1613{
Christopher Fauletc644fa92017-11-23 22:44:11 +01001614 char *slash;
1615 unsigned long proc = 0, thread = 0;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001616
Christopher Fauletc644fa92017-11-23 22:44:11 +01001617 if ((slash = strchr(args[cur_arg + 1], '/')) != NULL)
1618 *slash = 0;
1619
Willy Tarreauff9c9142019-02-07 10:39:36 +01001620 if (parse_process_number(args[cur_arg + 1], &proc, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +01001621 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001622 return ERR_ALERT | ERR_FATAL;
1623 }
1624
Christopher Fauletc644fa92017-11-23 22:44:11 +01001625 if (slash) {
Willy Tarreauc9a82e42019-01-26 13:25:14 +01001626 if (parse_process_number(slash+1, &thread, MAX_THREADS, NULL, err)) {
Christopher Fauletc644fa92017-11-23 22:44:11 +01001627 memprintf(err, "'%s' : %s", args[cur_arg], *err);
1628 return ERR_ALERT | ERR_FATAL;
1629 }
1630 *slash = '/';
1631 }
1632
Willy Tarreaue26993c2020-09-03 07:18:55 +02001633 conf->settings.bind_proc |= proc;
1634 conf->settings.bind_thread |= thread;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001635 return 0;
1636}
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001637
Christopher Fauleta717b992018-04-10 14:43:00 +02001638/* parse the "proto" bind keyword */
1639static int bind_parse_proto(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1640{
1641 struct ist proto;
1642
1643 if (!*args[cur_arg + 1]) {
1644 memprintf(err, "'%s' : missing value", args[cur_arg]);
1645 return ERR_ALERT | ERR_FATAL;
1646 }
1647
Tim Duesterhusdcf753a2021-03-04 17:31:47 +01001648 proto = ist(args[cur_arg + 1]);
Christopher Fauleta717b992018-04-10 14:43:00 +02001649 conf->mux_proto = get_mux_proto(proto);
1650 if (!conf->mux_proto) {
1651 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[cur_arg], args[cur_arg+1]);
1652 return ERR_ALERT | ERR_FATAL;
1653 }
Christopher Fauleta717b992018-04-10 14:43:00 +02001654 return 0;
1655}
1656
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001657/* config parser for global "tune.listener.multi-queue", accepts "on" or "off" */
1658static int cfg_parse_tune_listener_mq(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01001659 const struct proxy *defpx, const char *file, int line,
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001660 char **err)
1661{
1662 if (too_many_args(1, args, err, NULL))
1663 return -1;
1664
1665 if (strcmp(args[1], "on") == 0)
1666 global.tune.options |= GTUNE_LISTENER_MQ;
1667 else if (strcmp(args[1], "off") == 0)
1668 global.tune.options &= ~GTUNE_LISTENER_MQ;
1669 else {
1670 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
1671 return -1;
1672 }
1673 return 0;
1674}
1675
Willy Tarreau61612d42012-04-19 18:42:05 +02001676/* Note: must not be declared <const> as its list will be overwritten.
1677 * Please take care of keeping this list alphabetically sorted.
1678 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001679static struct sample_fetch_kw_list smp_kws = {ILH, {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001680 { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
1681 { "so_id", smp_fetch_so_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
Jerome Magnineb421b22020-03-27 22:08:40 +01001682 { "so_name", smp_fetch_so_name, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001683 { /* END */ },
1684}};
1685
Willy Tarreau0108d902018-11-25 19:14:37 +01001686INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1687
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001688/* Note: must not be declared <const> as its list will be overwritten.
1689 * Please take care of keeping this list alphabetically sorted.
1690 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001691static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001692 { /* END */ },
Willy Tarreau645513a2010-05-24 20:55:15 +02001693}};
1694
Willy Tarreau0108d902018-11-25 19:14:37 +01001695INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
1696
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001697/* Note: must not be declared <const> as its list will be overwritten.
1698 * Please take care of keeping this list alphabetically sorted, doing so helps
1699 * all code contributors.
1700 * Optional keywords are also declared with a NULL ->parse() function so that
1701 * the config parser can report an appropriate error when a known keyword was
1702 * not enabled.
1703 */
Willy Tarreau51fb7652012-09-18 18:24:39 +02001704static struct bind_kw_list bind_kws = { "ALL", { }, {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001705 { "accept-netscaler-cip", bind_parse_accept_netscaler_cip, 1 }, /* enable NetScaler Client IP insertion protocol */
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001706 { "accept-proxy", bind_parse_accept_proxy, 0 }, /* enable PROXY protocol */
1707 { "backlog", bind_parse_backlog, 1 }, /* set backlog of listening socket */
1708 { "id", bind_parse_id, 1 }, /* set id of listening socket */
1709 { "maxconn", bind_parse_maxconn, 1 }, /* set maxconn of listening socket */
1710 { "name", bind_parse_name, 1 }, /* set name of listening socket */
1711 { "nice", bind_parse_nice, 1 }, /* set nice of listening socket */
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001712 { "process", bind_parse_process, 1 }, /* set list of allowed process for this socket */
Christopher Fauleta717b992018-04-10 14:43:00 +02001713 { "proto", bind_parse_proto, 1 }, /* set the proto to use for all incoming connections */
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001714 { /* END */ },
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001715}};
1716
Willy Tarreau0108d902018-11-25 19:14:37 +01001717INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
1718
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001719/* config keyword parsers */
1720static struct cfg_kw_list cfg_kws = {ILH, {
1721 { CFG_GLOBAL, "tune.listener.multi-queue", cfg_parse_tune_listener_mq },
1722 { 0, NULL, NULL }
1723}};
1724
1725INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1726
Willy Tarreau645513a2010-05-24 20:55:15 +02001727/*
1728 * Local variables:
1729 * c-indent-level: 8
1730 * c-basic-offset: 8
1731 * End:
1732 */