blob: 017dcff4b1b909605639f97ff499d79739bfa426 [file] [log] [blame]
Willy Tarreaudd815982007-10-16 12:25:14 +02001/*
Willy Tarreaud1d54542012-09-12 22:58:11 +02002 * Listener management functions.
Willy Tarreaudd815982007-10-16 12:25:14 +02003 *
Willy Tarreau0ccb7442013-01-07 22:54:17 +01004 * Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
Willy Tarreaudd815982007-10-16 12:25:14 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau44489252014-01-14 17:52:01 +010013#define _GNU_SOURCE
Willy Tarreau6ae1ba62014-05-07 19:01:58 +020014#include <ctype.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020015#include <errno.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020016#include <stdio.h>
17#include <string.h>
Willy Tarreau95ccdde2014-02-01 09:28:36 +010018#include <unistd.h>
19#include <fcntl.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020020
Willy Tarreau1bc4aab2012-10-08 20:11:03 +020021#include <common/accept4.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020022#include <common/config.h>
Willy Tarreaudabf2e22007-10-28 21:59:24 +010023#include <common/errors.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020024#include <common/mini-clist.h>
25#include <common/standard.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020026#include <common/time.h>
27
28#include <types/global.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020029#include <types/protocol.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020030
Willy Tarreau645513a2010-05-24 20:55:15 +020031#include <proto/acl.h>
Willy Tarreaub648d632007-10-28 22:13:50 +010032#include <proto/fd.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020033#include <proto/freq_ctr.h>
34#include <proto/log.h>
Willy Tarreau0ccb7442013-01-07 22:54:17 +010035#include <proto/sample.h>
Willy Tarreaufb0afa72015-04-03 14:46:27 +020036#include <proto/stream.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020037#include <proto/task.h>
Willy Tarreaub648d632007-10-28 22:13:50 +010038
Willy Tarreau26982662012-09-12 23:17:10 +020039/* List head of all known bind keywords */
40static struct bind_kw_list bind_keywords = {
41 .list = LIST_HEAD_INIT(bind_keywords.list)
42};
43
Willy Tarreaudabf2e22007-10-28 21:59:24 +010044/* This function adds the specified listener's file descriptor to the polling
45 * lists if it is in the LI_LISTEN state. The listener enters LI_READY or
Willy Tarreauae302532014-05-07 19:22:24 +020046 * LI_FULL state depending on its number of connections. In deamon mode, we
47 * also support binding only the relevant processes to their respective
48 * listeners. We don't do that in debug mode however.
Willy Tarreaudabf2e22007-10-28 21:59:24 +010049 */
50void enable_listener(struct listener *listener)
51{
52 if (listener->state == LI_LISTEN) {
Willy Tarreauae302532014-05-07 19:22:24 +020053 if ((global.mode & (MODE_DAEMON | MODE_SYSTEMD)) &&
54 listener->bind_conf->bind_proc &&
55 !(listener->bind_conf->bind_proc & (1UL << (relative_pid - 1)))) {
56 /* we don't want to enable this listener and don't
57 * want any fd event to reach it.
58 */
59 fd_stop_recv(listener->fd);
60 listener->state = LI_PAUSED;
61 }
62 else if (listener->nbconn < listener->maxconn) {
Willy Tarreau49b046d2012-08-09 12:11:58 +020063 fd_want_recv(listener->fd);
Willy Tarreaudabf2e22007-10-28 21:59:24 +010064 listener->state = LI_READY;
Willy Tarreauae302532014-05-07 19:22:24 +020065 }
66 else {
Willy Tarreaudabf2e22007-10-28 21:59:24 +010067 listener->state = LI_FULL;
68 }
69 }
70}
71
72/* This function removes the specified listener's file descriptor from the
73 * polling lists if it is in the LI_READY or in the LI_FULL state. The listener
74 * enters LI_LISTEN.
75 */
76void disable_listener(struct listener *listener)
77{
78 if (listener->state < LI_READY)
79 return;
80 if (listener->state == LI_READY)
Willy Tarreau49b046d2012-08-09 12:11:58 +020081 fd_stop_recv(listener->fd);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +020082 if (listener->state == LI_LIMITED)
83 LIST_DEL(&listener->wait_queue);
Willy Tarreaudabf2e22007-10-28 21:59:24 +010084 listener->state = LI_LISTEN;
85}
86
Willy Tarreaube58c382011-07-24 18:28:10 +020087/* This function tries to temporarily disable a listener, depending on the OS
88 * capabilities. Linux unbinds the listen socket after a SHUT_RD, and ignores
89 * SHUT_WR. Solaris refuses either shutdown(). OpenBSD ignores SHUT_RD but
90 * closes upon SHUT_WR and refuses to rebind. So a common validation path
91 * involves SHUT_WR && listen && SHUT_RD. In case of success, the FD's polling
92 * is disabled. It normally returns non-zero, unless an error is reported.
93 */
94int pause_listener(struct listener *l)
95{
96 if (l->state <= LI_PAUSED)
97 return 1;
98
Willy Tarreau092d8652014-07-07 20:22:12 +020099 if (l->proto->pause) {
100 /* Returns < 0 in case of failure, 0 if the listener
101 * was totally stopped, or > 0 if correctly paused.
102 */
103 int ret = l->proto->pause(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200104
Willy Tarreau092d8652014-07-07 20:22:12 +0200105 if (ret < 0)
106 return 0;
107 else if (ret == 0)
108 return 1;
Willy Tarreaub3fb60b2012-10-04 08:56:31 +0200109 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200110
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200111 if (l->state == LI_LIMITED)
112 LIST_DEL(&l->wait_queue);
113
Willy Tarreau49b046d2012-08-09 12:11:58 +0200114 fd_stop_recv(l->fd);
Willy Tarreaube58c382011-07-24 18:28:10 +0200115 l->state = LI_PAUSED;
116 return 1;
117}
118
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200119/* This function tries to resume a temporarily disabled listener. Paused, full,
120 * limited and disabled listeners are handled, which means that this function
121 * may replace enable_listener(). The resulting state will either be LI_READY
122 * or LI_FULL. 0 is returned in case of failure to resume (eg: dead socket).
Willy Tarreauae302532014-05-07 19:22:24 +0200123 * Listeners bound to a different process are not woken up unless we're in
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200124 * foreground mode, and are ignored. If the listener was only in the assigned
125 * state, it's totally rebound. This can happen if a pause() has completely
126 * stopped it. If the resume fails, 0 is returned and an error might be
127 * displayed.
Willy Tarreaube58c382011-07-24 18:28:10 +0200128 */
129int resume_listener(struct listener *l)
130{
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200131 if (l->state == LI_ASSIGNED) {
132 char msg[100];
133 int err;
134
135 err = l->proto->bind(l, msg, sizeof(msg));
136 if (err & ERR_ALERT)
137 Alert("Resuming listener: %s\n", msg);
138 else if (err & ERR_WARN)
139 Warning("Resuming listener: %s\n", msg);
140
141 if (err & (ERR_FATAL | ERR_ABORT))
142 return 0;
143 }
144
Willy Tarreaube58c382011-07-24 18:28:10 +0200145 if (l->state < LI_PAUSED)
146 return 0;
147
Willy Tarreauae302532014-05-07 19:22:24 +0200148 if ((global.mode & (MODE_DAEMON | MODE_SYSTEMD)) &&
149 l->bind_conf->bind_proc &&
150 !(l->bind_conf->bind_proc & (1UL << (relative_pid - 1))))
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200151 return 1;
Willy Tarreauae302532014-05-07 19:22:24 +0200152
Willy Tarreaub3fb60b2012-10-04 08:56:31 +0200153 if (l->proto->sock_prot == IPPROTO_TCP &&
154 l->state == LI_PAUSED &&
Willy Tarreaube58c382011-07-24 18:28:10 +0200155 listen(l->fd, l->backlog ? l->backlog : l->maxconn) != 0)
156 return 0;
157
158 if (l->state == LI_READY)
159 return 1;
160
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200161 if (l->state == LI_LIMITED)
162 LIST_DEL(&l->wait_queue);
163
Willy Tarreaube58c382011-07-24 18:28:10 +0200164 if (l->nbconn >= l->maxconn) {
165 l->state = LI_FULL;
166 return 1;
167 }
168
Willy Tarreau49b046d2012-08-09 12:11:58 +0200169 fd_want_recv(l->fd);
Willy Tarreaube58c382011-07-24 18:28:10 +0200170 l->state = LI_READY;
171 return 1;
172}
173
Willy Tarreau87b09662015-04-03 00:22:06 +0200174/* Marks a ready listener as full so that the stream code tries to re-enable
Willy Tarreau62793712011-07-24 19:23:38 +0200175 * it upon next close() using resume_listener().
176 */
177void listener_full(struct listener *l)
178{
179 if (l->state >= LI_READY) {
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200180 if (l->state == LI_LIMITED)
181 LIST_DEL(&l->wait_queue);
182
Willy Tarreau49b046d2012-08-09 12:11:58 +0200183 fd_stop_recv(l->fd);
Willy Tarreau62793712011-07-24 19:23:38 +0200184 l->state = LI_FULL;
185 }
186}
187
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200188/* Marks a ready listener as limited so that we only try to re-enable it when
189 * resources are free again. It will be queued into the specified queue.
190 */
191void limit_listener(struct listener *l, struct list *list)
192{
193 if (l->state == LI_READY) {
194 LIST_ADDQ(list, &l->wait_queue);
Willy Tarreau49b046d2012-08-09 12:11:58 +0200195 fd_stop_recv(l->fd);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200196 l->state = LI_LIMITED;
197 }
198}
199
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100200/* This function adds all of the protocol's listener's file descriptors to the
201 * polling lists when they are in the LI_LISTEN state. It is intended to be
202 * used as a protocol's generic enable_all() primitive, for use after the
203 * fork(). It puts the listeners into LI_READY or LI_FULL states depending on
204 * their number of connections. It always returns ERR_NONE.
205 */
206int enable_all_listeners(struct protocol *proto)
207{
208 struct listener *listener;
209
210 list_for_each_entry(listener, &proto->listeners, proto_list)
211 enable_listener(listener);
212 return ERR_NONE;
213}
214
215/* This function removes all of the protocol's listener's file descriptors from
216 * the polling lists when they are in the LI_READY or LI_FULL states. It is
217 * intended to be used as a protocol's generic disable_all() primitive. It puts
218 * the listeners into LI_LISTEN, and always returns ERR_NONE.
219 */
220int disable_all_listeners(struct protocol *proto)
221{
222 struct listener *listener;
223
224 list_for_each_entry(listener, &proto->listeners, proto_list)
225 disable_listener(listener);
226 return ERR_NONE;
227}
228
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200229/* Dequeues all of the listeners waiting for a resource in wait queue <queue>. */
230void dequeue_all_listeners(struct list *list)
231{
232 struct listener *listener, *l_back;
233
234 list_for_each_entry_safe(listener, l_back, list, wait_queue) {
235 /* This cannot fail because the listeners are by definition in
236 * the LI_LIMITED state. The function also removes the entry
237 * from the queue.
238 */
239 resume_listener(listener);
240 }
241}
242
Willy Tarreaub648d632007-10-28 22:13:50 +0100243/* This function closes the listening socket for the specified listener,
244 * provided that it's already in a listening state. The listener enters the
245 * LI_ASSIGNED state. It always returns ERR_NONE. This function is intended
246 * to be used as a generic function for standard protocols.
247 */
248int unbind_listener(struct listener *listener)
249{
250 if (listener->state == LI_READY)
Willy Tarreau49b046d2012-08-09 12:11:58 +0200251 fd_stop_recv(listener->fd);
Willy Tarreaub648d632007-10-28 22:13:50 +0100252
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200253 if (listener->state == LI_LIMITED)
254 LIST_DEL(&listener->wait_queue);
255
Willy Tarreaube58c382011-07-24 18:28:10 +0200256 if (listener->state >= LI_PAUSED) {
Willy Tarreaub648d632007-10-28 22:13:50 +0100257 fd_delete(listener->fd);
Willy Tarreau39447b62014-07-07 18:24:48 +0200258 listener->fd = -1;
Willy Tarreaub648d632007-10-28 22:13:50 +0100259 listener->state = LI_ASSIGNED;
260 }
261 return ERR_NONE;
262}
263
Willy Tarreau3acf8c32007-10-28 22:35:41 +0100264/* This function closes all listening sockets bound to the protocol <proto>,
265 * and the listeners end in LI_ASSIGNED state if they were higher. It does not
266 * detach them from the protocol. It always returns ERR_NONE.
267 */
268int unbind_all_listeners(struct protocol *proto)
269{
270 struct listener *listener;
271
272 list_for_each_entry(listener, &proto->listeners, proto_list)
273 unbind_listener(listener);
274 return ERR_NONE;
275}
276
Willy Tarreau1a64d162007-10-28 22:26:05 +0100277/* Delete a listener from its protocol's list of listeners. The listener's
278 * state is automatically updated from LI_ASSIGNED to LI_INIT. The protocol's
279 * number of listeners is updated. Note that the listener must have previously
280 * been unbound. This is the generic function to use to remove a listener.
281 */
282void delete_listener(struct listener *listener)
283{
284 if (listener->state != LI_ASSIGNED)
285 return;
286 listener->state = LI_INIT;
287 LIST_DEL(&listener->proto_list);
288 listener->proto->nb_listeners--;
289}
290
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200291/* This function is called on a read event from a listening socket, corresponding
292 * to an accept. It tries to accept as many connections as possible, and for each
293 * calls the listener's accept handler (generally the frontend's accept handler).
294 */
Willy Tarreauafad0e02012-08-09 14:45:22 +0200295void listener_accept(int fd)
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200296{
297 struct listener *l = fdtab[fd].owner;
298 struct proxy *p = l->frontend;
Willy Tarreau50de90a2012-11-23 20:11:45 +0100299 int max_accept = l->maxaccept ? l->maxaccept : 1;
Willy Tarreaubb660302014-05-07 19:47:02 +0200300 int expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200301 int cfd;
302 int ret;
Willy Tarreau818dca52014-01-31 19:40:19 +0100303#ifdef USE_ACCEPT4
304 static int accept4_broken;
305#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200306
307 if (unlikely(l->nbconn >= l->maxconn)) {
308 listener_full(l);
Willy Tarreauafad0e02012-08-09 14:45:22 +0200309 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200310 }
311
Willy Tarreau93e7c002013-10-07 18:51:07 +0200312 if (!(l->options & LI_O_UNLIMITED) && global.sps_lim) {
313 int max = freq_ctr_remain(&global.sess_per_sec, global.sps_lim, 0);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200314
315 if (unlikely(!max)) {
316 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200317 expire = tick_add(now_ms, next_event_delay(&global.sess_per_sec, global.sps_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200318 goto wait_expire;
Willy Tarreau93e7c002013-10-07 18:51:07 +0200319 }
320
321 if (max_accept > max)
322 max_accept = max;
323 }
324
325 if (!(l->options & LI_O_UNLIMITED) && global.cps_lim) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200326 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
327
328 if (unlikely(!max)) {
329 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200330 expire = tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200331 goto wait_expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200332 }
333
334 if (max_accept > max)
335 max_accept = max;
336 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200337#ifdef USE_OPENSSL
338 if (!(l->options & LI_O_UNLIMITED) && global.ssl_lim && l->bind_conf && l->bind_conf->is_ssl) {
339 int max = freq_ctr_remain(&global.ssl_per_sec, global.ssl_lim, 0);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200340
Willy Tarreaue43d5322013-10-07 20:01:52 +0200341 if (unlikely(!max)) {
342 /* frontend accept rate limit was reached */
Willy Tarreaue43d5322013-10-07 20:01:52 +0200343 expire = tick_add(now_ms, next_event_delay(&global.ssl_per_sec, global.ssl_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200344 goto wait_expire;
Willy Tarreaue43d5322013-10-07 20:01:52 +0200345 }
346
347 if (max_accept > max)
348 max_accept = max;
349 }
350#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200351 if (p && p->fe_sps_lim) {
352 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
353
354 if (unlikely(!max)) {
355 /* frontend accept rate limit was reached */
356 limit_listener(l, &p->listener_queue);
357 task_schedule(p->task, tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0)));
Willy Tarreauafad0e02012-08-09 14:45:22 +0200358 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200359 }
360
361 if (max_accept > max)
362 max_accept = max;
363 }
364
365 /* Note: if we fail to allocate a connection because of configured
366 * limits, we'll schedule a new attempt worst 1 second later in the
367 * worst case. If we fail due to system limits or temporary resource
368 * shortage, we try again 100ms later in the worst case.
369 */
370 while (max_accept--) {
371 struct sockaddr_storage addr;
372 socklen_t laddr = sizeof(addr);
373
374 if (unlikely(actconn >= global.maxconn) && !(l->options & LI_O_UNLIMITED)) {
375 limit_listener(l, &global_listener_queue);
376 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreauafad0e02012-08-09 14:45:22 +0200377 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200378 }
379
380 if (unlikely(p && p->feconn >= p->maxconn)) {
381 limit_listener(l, &p->listener_queue);
Willy Tarreauafad0e02012-08-09 14:45:22 +0200382 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200383 }
384
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200385#ifdef USE_ACCEPT4
Willy Tarreau818dca52014-01-31 19:40:19 +0100386 /* only call accept4() if it's known to be safe, otherwise
387 * fallback to the legacy accept() + fcntl().
388 */
389 if (unlikely(accept4_broken ||
390 ((cfd = accept4(fd, (struct sockaddr *)&addr, &laddr, SOCK_NONBLOCK)) == -1 &&
391 (errno == ENOSYS || errno == EINVAL || errno == EBADF) &&
392 (accept4_broken = 1))))
393#endif
Willy Tarreau6b3b0d42012-10-22 19:32:55 +0200394 if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) != -1)
395 fcntl(cfd, F_SETFL, O_NONBLOCK);
Willy Tarreau818dca52014-01-31 19:40:19 +0100396
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200397 if (unlikely(cfd == -1)) {
398 switch (errno) {
399 case EAGAIN:
Willy Tarreaubb660302014-05-07 19:47:02 +0200400 if (fdtab[fd].ev & FD_POLL_HUP) {
401 /* the listening socket might have been disabled in a shared
402 * process and we're a collateral victim. We'll just pause for
403 * a while in case it comes back. In the mean time, we need to
404 * clear this sticky flag.
405 */
406 fdtab[fd].ev &= ~FD_POLL_HUP;
407 goto transient_error;
408 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100409 fd_cant_recv(fd);
Willy Tarreauafad0e02012-08-09 14:45:22 +0200410 return; /* nothing more to accept */
Willy Tarreaubb660302014-05-07 19:47:02 +0200411 case EINVAL:
412 /* might be trying to accept on a shut fd (eg: soft stop) */
413 goto transient_error;
Willy Tarreaua593ec52014-01-20 21:21:30 +0100414 case EINTR:
415 case ECONNABORTED:
416 continue;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200417 case ENFILE:
418 if (p)
419 send_log(p, LOG_EMERG,
420 "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
421 p->id, maxfd);
Willy Tarreaubb660302014-05-07 19:47:02 +0200422 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200423 case EMFILE:
424 if (p)
425 send_log(p, LOG_EMERG,
426 "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
427 p->id, maxfd);
Willy Tarreaubb660302014-05-07 19:47:02 +0200428 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200429 case ENOBUFS:
430 case ENOMEM:
431 if (p)
432 send_log(p, LOG_EMERG,
433 "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
434 p->id, maxfd);
Willy Tarreaubb660302014-05-07 19:47:02 +0200435 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200436 default:
Willy Tarreaua593ec52014-01-20 21:21:30 +0100437 /* unexpected result, let's give up and let other tasks run */
Willy Tarreau6c11bd22014-01-24 00:54:27 +0100438 goto stop;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200439 }
440 }
441
442 if (unlikely(cfd >= global.maxsock)) {
443 send_log(p, LOG_EMERG,
444 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
445 p->id);
446 close(cfd);
447 limit_listener(l, &global_listener_queue);
448 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreauafad0e02012-08-09 14:45:22 +0200449 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200450 }
451
452 /* increase the per-process number of cumulated connections */
453 if (!(l->options & LI_O_UNLIMITED)) {
454 update_freq_ctr(&global.conn_per_sec, 1);
455 if (global.conn_per_sec.curr_ctr > global.cps_max)
456 global.cps_max = global.conn_per_sec.curr_ctr;
457 actconn++;
458 }
459
460 jobs++;
461 totalconn++;
462 l->nbconn++;
463
464 if (l->counters) {
465 if (l->nbconn > l->counters->conn_max)
466 l->counters->conn_max = l->nbconn;
467 }
468
469 ret = l->accept(l, cfd, &addr);
470 if (unlikely(ret <= 0)) {
Willy Tarreau87b09662015-04-03 00:22:06 +0200471 /* The connection was closed by stream_accept(). Either
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200472 * we just have to ignore it (ret == 0) or it's a critical
473 * error due to a resource shortage, and we must stop the
474 * listener (ret < 0).
475 */
476 if (!(l->options & LI_O_UNLIMITED))
477 actconn--;
478 jobs--;
479 l->nbconn--;
480 if (ret == 0) /* successful termination */
481 continue;
482
Willy Tarreaubb660302014-05-07 19:47:02 +0200483 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200484 }
485
486 if (l->nbconn >= l->maxconn) {
487 listener_full(l);
Willy Tarreauafad0e02012-08-09 14:45:22 +0200488 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200489 }
490
Willy Tarreau93e7c002013-10-07 18:51:07 +0200491 /* increase the per-process number of cumulated connections */
492 if (!(l->options & LI_O_UNLIMITED)) {
493 update_freq_ctr(&global.sess_per_sec, 1);
494 if (global.sess_per_sec.curr_ctr > global.sps_max)
495 global.sps_max = global.sess_per_sec.curr_ctr;
496 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200497#ifdef USE_OPENSSL
498 if (!(l->options & LI_O_UNLIMITED) && l->bind_conf && l->bind_conf->is_ssl) {
499
500 update_freq_ctr(&global.ssl_per_sec, 1);
501 if (global.ssl_per_sec.curr_ctr > global.ssl_max)
502 global.ssl_max = global.ssl_per_sec.curr_ctr;
503 }
504#endif
Willy Tarreau93e7c002013-10-07 18:51:07 +0200505
Willy Tarreauaece46a2012-07-06 12:25:58 +0200506 } /* end of while (max_accept--) */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200507
Willy Tarreauaece46a2012-07-06 12:25:58 +0200508 /* we've exhausted max_accept, so there is no need to poll again */
Willy Tarreau6c11bd22014-01-24 00:54:27 +0100509 stop:
510 fd_done_recv(fd);
Willy Tarreauafad0e02012-08-09 14:45:22 +0200511 return;
Willy Tarreaubb660302014-05-07 19:47:02 +0200512
513 transient_error:
514 /* pause the listener and try again in 100 ms */
515 expire = tick_add(now_ms, 100);
516
517 wait_expire:
518 limit_listener(l, &global_listener_queue);
519 task_schedule(global_listener_queue_task, tick_first(expire, global_listener_queue_task->expire));
520 return;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200521}
522
Willy Tarreau26982662012-09-12 23:17:10 +0200523/*
524 * Registers the bind keyword list <kwl> as a list of valid keywords for next
525 * parsing sessions.
526 */
527void bind_register_keywords(struct bind_kw_list *kwl)
528{
529 LIST_ADDQ(&bind_keywords.list, &kwl->list);
530}
531
532/* Return a pointer to the bind keyword <kw>, or NULL if not found. If the
533 * keyword is found with a NULL ->parse() function, then an attempt is made to
534 * find one with a valid ->parse() function. This way it is possible to declare
535 * platform-dependant, known keywords as NULL, then only declare them as valid
536 * if some options are met. Note that if the requested keyword contains an
537 * opening parenthesis, everything from this point is ignored.
538 */
539struct bind_kw *bind_find_kw(const char *kw)
540{
541 int index;
542 const char *kwend;
543 struct bind_kw_list *kwl;
544 struct bind_kw *ret = NULL;
545
546 kwend = strchr(kw, '(');
547 if (!kwend)
548 kwend = kw + strlen(kw);
549
550 list_for_each_entry(kwl, &bind_keywords.list, list) {
551 for (index = 0; kwl->kw[index].kw != NULL; index++) {
552 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
553 kwl->kw[index].kw[kwend-kw] == 0) {
554 if (kwl->kw[index].parse)
555 return &kwl->kw[index]; /* found it !*/
556 else
557 ret = &kwl->kw[index]; /* may be OK */
558 }
559 }
560 }
561 return ret;
562}
563
Willy Tarreau8638f482012-09-18 18:01:17 +0200564/* Dumps all registered "bind" keywords to the <out> string pointer. The
565 * unsupported keywords are only dumped if their supported form was not
566 * found.
567 */
568void bind_dump_kws(char **out)
569{
570 struct bind_kw_list *kwl;
571 int index;
572
573 *out = NULL;
574 list_for_each_entry(kwl, &bind_keywords.list, list) {
575 for (index = 0; kwl->kw[index].kw != NULL; index++) {
576 if (kwl->kw[index].parse ||
577 bind_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
Willy Tarreau51fb7652012-09-18 18:24:39 +0200578 memprintf(out, "%s[%4s] %s%s%s\n", *out ? *out : "",
579 kwl->scope,
Willy Tarreau8638f482012-09-18 18:01:17 +0200580 kwl->kw[index].kw,
Willy Tarreau51fb7652012-09-18 18:24:39 +0200581 kwl->kw[index].skip ? " <arg>" : "",
582 kwl->kw[index].parse ? "" : " (not supported)");
Willy Tarreau8638f482012-09-18 18:01:17 +0200583 }
584 }
585 }
586}
587
Willy Tarreau645513a2010-05-24 20:55:15 +0200588/************************************************************************/
Willy Tarreau0ccb7442013-01-07 22:54:17 +0100589/* All supported sample and ACL keywords must be declared here. */
Willy Tarreau645513a2010-05-24 20:55:15 +0200590/************************************************************************/
591
Willy Tarreaua5e37562011-12-16 17:06:15 +0100592/* set temp integer to the number of connexions to the same listening socket */
Willy Tarreau645513a2010-05-24 20:55:15 +0200593static int
Willy Tarreau192252e2015-04-04 01:47:55 +0200594smp_fetch_dconn(struct proxy *px, struct session *sess, struct stream *strm, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +0100595 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau645513a2010-05-24 20:55:15 +0200596{
Willy Tarreauf853c462012-04-23 18:53:56 +0200597 smp->type = SMP_T_UINT;
Willy Tarreau192252e2015-04-04 01:47:55 +0200598 smp->data.uint = sess->listener->nbconn;
Willy Tarreau645513a2010-05-24 20:55:15 +0200599 return 1;
600}
601
Willy Tarreaua5e37562011-12-16 17:06:15 +0100602/* set temp integer to the id of the socket (listener) */
Willy Tarreau645513a2010-05-24 20:55:15 +0200603static int
Willy Tarreau192252e2015-04-04 01:47:55 +0200604smp_fetch_so_id(struct proxy *px, struct session *sess, struct stream *strm, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +0100605 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau37406352012-04-23 16:16:37 +0200606{
Willy Tarreauf853c462012-04-23 18:53:56 +0200607 smp->type = SMP_T_UINT;
Willy Tarreau192252e2015-04-04 01:47:55 +0200608 smp->data.uint = sess->listener->luid;
Willy Tarreau645513a2010-05-24 20:55:15 +0200609 return 1;
610}
611
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200612/* parse the "accept-proxy" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +0200613static 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 +0200614{
615 struct listener *l;
616
Willy Tarreau4348fad2012-09-20 16:48:07 +0200617 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200618 l->options |= LI_O_ACC_PROXY;
619
620 return 0;
621}
622
623/* parse the "backlog" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +0200624static 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 +0200625{
626 struct listener *l;
627 int val;
628
629 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200630 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200631 return ERR_ALERT | ERR_FATAL;
632 }
633
634 val = atol(args[cur_arg + 1]);
635 if (val <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200636 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200637 return ERR_ALERT | ERR_FATAL;
638 }
639
Willy Tarreau4348fad2012-09-20 16:48:07 +0200640 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200641 l->backlog = val;
642
643 return 0;
644}
645
646/* parse the "id" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +0200647static 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 +0200648{
649 struct eb32_node *node;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200650 struct listener *l, *new;
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200651
Willy Tarreau4348fad2012-09-20 16:48:07 +0200652 if (conf->listeners.n != conf->listeners.p) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200653 memprintf(err, "'%s' can only be used with a single socket", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200654 return ERR_ALERT | ERR_FATAL;
655 }
656
657 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200658 memprintf(err, "'%s' : expects an integer argument", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200659 return ERR_ALERT | ERR_FATAL;
660 }
661
Willy Tarreau4348fad2012-09-20 16:48:07 +0200662 new = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
663 new->luid = atol(args[cur_arg + 1]);
664 new->conf.id.key = new->luid;
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200665
Willy Tarreau4348fad2012-09-20 16:48:07 +0200666 if (new->luid <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200667 memprintf(err, "'%s' : custom id has to be > 0", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200668 return ERR_ALERT | ERR_FATAL;
669 }
670
Willy Tarreau4348fad2012-09-20 16:48:07 +0200671 node = eb32_lookup(&px->conf.used_listener_id, new->luid);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200672 if (node) {
673 l = container_of(node, struct listener, conf.id);
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200674 memprintf(err, "'%s' : custom id %d already used at %s:%d ('bind %s')",
675 args[cur_arg], l->luid, l->bind_conf->file, l->bind_conf->line,
676 l->bind_conf->arg);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200677 return ERR_ALERT | ERR_FATAL;
678 }
679
Willy Tarreau4348fad2012-09-20 16:48:07 +0200680 eb32_insert(&px->conf.used_listener_id, &new->conf.id);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200681 return 0;
682}
683
684/* parse the "maxconn" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +0200685static 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 +0200686{
687 struct listener *l;
688 int val;
689
690 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200691 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200692 return ERR_ALERT | ERR_FATAL;
693 }
694
695 val = atol(args[cur_arg + 1]);
696 if (val <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200697 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200698 return ERR_ALERT | ERR_FATAL;
699 }
700
Willy Tarreau4348fad2012-09-20 16:48:07 +0200701 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200702 l->maxconn = val;
703
704 return 0;
705}
706
707/* parse the "name" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +0200708static 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 +0200709{
710 struct listener *l;
711
712 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200713 memprintf(err, "'%s' : missing name", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200714 return ERR_ALERT | ERR_FATAL;
715 }
716
Willy Tarreau4348fad2012-09-20 16:48:07 +0200717 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200718 l->name = strdup(args[cur_arg + 1]);
719
720 return 0;
721}
722
723/* parse the "nice" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +0200724static 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 +0200725{
726 struct listener *l;
727 int val;
728
729 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200730 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200731 return ERR_ALERT | ERR_FATAL;
732 }
733
734 val = atol(args[cur_arg + 1]);
735 if (val < -1024 || val > 1024) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200736 memprintf(err, "'%s' : invalid value %d, allowed range is -1024..1024", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200737 return ERR_ALERT | ERR_FATAL;
738 }
739
Willy Tarreau4348fad2012-09-20 16:48:07 +0200740 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200741 l->nice = val;
742
743 return 0;
744}
745
Willy Tarreau6ae1ba62014-05-07 19:01:58 +0200746/* parse the "process" bind keyword */
747static int bind_parse_process(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
748{
749 unsigned long set = 0;
750 unsigned int low, high;
751
752 if (strcmp(args[cur_arg + 1], "all") == 0) {
753 set = 0;
754 }
755 else if (strcmp(args[cur_arg + 1], "odd") == 0) {
756 set |= ~0UL/3UL; /* 0x555....555 */
757 }
758 else if (strcmp(args[cur_arg + 1], "even") == 0) {
759 set |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
760 }
761 else if (isdigit((int)*args[cur_arg + 1])) {
762 char *dash = strchr(args[cur_arg + 1], '-');
763
764 low = high = str2uic(args[cur_arg + 1]);
765 if (dash)
766 high = str2uic(dash + 1);
767
768 if (high < low) {
769 unsigned int swap = low;
770 low = high;
771 high = swap;
772 }
773
774 if (low < 1 || high > LONGBITS) {
775 memprintf(err, "'%s' : invalid range %d-%d, allowed range is 1..%d", args[cur_arg], low, high, LONGBITS);
776 return ERR_ALERT | ERR_FATAL;
777 }
778 while (low <= high)
779 set |= 1UL << (low++ - 1);
780 }
781 else {
782 memprintf(err, "'%s' expects 'all', 'odd', 'even', or a process range with numbers from 1 to %d.", args[cur_arg], LONGBITS);
783 return ERR_ALERT | ERR_FATAL;
784 }
785
786 conf->bind_proc = set;
787 return 0;
788}
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200789
Willy Tarreau61612d42012-04-19 18:42:05 +0200790/* Note: must not be declared <const> as its list will be overwritten.
791 * Please take care of keeping this list alphabetically sorted.
792 */
Willy Tarreaudc13c112013-06-21 23:16:39 +0200793static struct sample_fetch_kw_list smp_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +0100794 { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_UINT, SMP_USE_FTEND, },
795 { "so_id", smp_fetch_so_id, 0, NULL, SMP_T_UINT, SMP_USE_FTEND, },
796 { /* END */ },
797}};
798
799/* Note: must not be declared <const> as its list will be overwritten.
800 * Please take care of keeping this list alphabetically sorted.
801 */
Willy Tarreaudc13c112013-06-21 23:16:39 +0200802static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +0100803 { /* END */ },
Willy Tarreau645513a2010-05-24 20:55:15 +0200804}};
805
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200806/* Note: must not be declared <const> as its list will be overwritten.
807 * Please take care of keeping this list alphabetically sorted, doing so helps
808 * all code contributors.
809 * Optional keywords are also declared with a NULL ->parse() function so that
810 * the config parser can report an appropriate error when a known keyword was
811 * not enabled.
812 */
Willy Tarreau51fb7652012-09-18 18:24:39 +0200813static struct bind_kw_list bind_kws = { "ALL", { }, {
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200814 { "accept-proxy", bind_parse_accept_proxy, 0 }, /* enable PROXY protocol */
815 { "backlog", bind_parse_backlog, 1 }, /* set backlog of listening socket */
816 { "id", bind_parse_id, 1 }, /* set id of listening socket */
817 { "maxconn", bind_parse_maxconn, 1 }, /* set maxconn of listening socket */
818 { "name", bind_parse_name, 1 }, /* set name of listening socket */
819 { "nice", bind_parse_nice, 1 }, /* set nice of listening socket */
Willy Tarreau6ae1ba62014-05-07 19:01:58 +0200820 { "process", bind_parse_process, 1 }, /* set list of allowed process for this socket */
Willy Tarreau0ccb7442013-01-07 22:54:17 +0100821 { /* END */ },
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200822}};
823
Willy Tarreau645513a2010-05-24 20:55:15 +0200824__attribute__((constructor))
Willy Tarreaud1d54542012-09-12 22:58:11 +0200825static void __listener_init(void)
Willy Tarreau645513a2010-05-24 20:55:15 +0200826{
Willy Tarreau0ccb7442013-01-07 22:54:17 +0100827 sample_register_fetches(&smp_kws);
Willy Tarreau645513a2010-05-24 20:55:15 +0200828 acl_register_keywords(&acl_kws);
Willy Tarreau3dcc3412012-09-18 17:17:28 +0200829 bind_register_keywords(&bind_kws);
Willy Tarreau645513a2010-05-24 20:55:15 +0200830}
831
832/*
833 * Local variables:
834 * c-indent-level: 8
835 * c-basic-offset: 8
836 * End:
837 */