blob: 5506ed5ce875e09c575b5c3bc0d9f96ec9d61cbe [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * HA-Proxy : High Availability-enabled HTTP/TCP proxy
Willy Tarreau7b677262017-04-03 09:27:49 +02003 * Copyright 2000-2017 Willy Tarreau <willy@haproxy.org>.
Willy Tarreaubaaee002006-06-26 02:48:02 +02004 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
9 *
Lukas Tribus23953682017-04-28 13:24:30 +000010 * Please refer to RFC7230 - RFC7235 informations about HTTP protocol, and
11 * RFC6265 for informations about cookies usage. More generally, the IETF HTTP
Willy Tarreaubaaee002006-06-26 02:48:02 +020012 * Working Group's web site should be consulted for protocol related changes :
13 *
14 * http://ftp.ics.uci.edu/pub/ietf/http/
15 *
16 * Pending bugs (may be not fixed because never reproduced) :
17 * - solaris only : sometimes, an HTTP proxy with only a dispatch address causes
18 * the proxy to terminate (no core) if the client breaks the connection during
19 * the response. Seen on 1.1.8pre4, but never reproduced. May not be related to
20 * the snprintf() bug since requests were simple (GET / HTTP/1.0), but may be
21 * related to missing setsid() (fixed in 1.1.15)
22 * - a proxy with an invalid config will prevent the startup even if disabled.
23 *
24 * ChangeLog has moved to the CHANGELOG file.
25 *
Willy Tarreaubaaee002006-06-26 02:48:02 +020026 */
27
David Carlier7ece0962015-12-08 21:43:09 +000028#define _GNU_SOURCE
Willy Tarreaubaaee002006-06-26 02:48:02 +020029#include <stdio.h>
30#include <stdlib.h>
31#include <unistd.h>
32#include <string.h>
33#include <ctype.h>
Maxime de Roucy379d9c72016-05-13 23:52:56 +020034#include <dirent.h>
Maxime de Roucy379d9c72016-05-13 23:52:56 +020035#include <sys/stat.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036#include <sys/time.h>
37#include <sys/types.h>
38#include <sys/socket.h>
39#include <netinet/tcp.h>
40#include <netinet/in.h>
41#include <arpa/inet.h>
Olivier Houchardf73629d2017-04-05 22:33:04 +020042#include <net/if.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020043#include <netdb.h>
44#include <fcntl.h>
45#include <errno.h>
46#include <signal.h>
47#include <stdarg.h>
48#include <sys/resource.h>
Marc-Antoine Perennou992709b2013-02-12 10:53:52 +010049#include <sys/wait.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020050#include <time.h>
51#include <syslog.h>
Michael Schererab012dd2013-01-12 18:35:19 +010052#include <grp.h>
Willy Tarreaufc6c0322012-11-16 16:12:27 +010053#ifdef USE_CPU_AFFINITY
Willy Tarreaufc6c0322012-11-16 16:12:27 +010054#include <sched.h>
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +020055#ifdef __FreeBSD__
56#include <sys/param.h>
57#include <sys/cpuset.h>
58#endif
Willy Tarreaufc6c0322012-11-16 16:12:27 +010059#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +020060
61#ifdef DEBUG_FULL
62#include <assert.h>
63#endif
64
Willy Tarreau2dd0d472006-06-29 17:53:05 +020065#include <common/base64.h>
66#include <common/cfgparse.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020067#include <common/chunk.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020068#include <common/compat.h>
69#include <common/config.h>
70#include <common/defaults.h>
Willy Tarreaud740bab2007-10-28 11:14:07 +010071#include <common/errors.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020072#include <common/memory.h>
73#include <common/mini-clist.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010074#include <common/namespace.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020075#include <common/regex.h>
76#include <common/standard.h>
77#include <common/time.h>
78#include <common/uri_auth.h>
79#include <common/version.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020080
81#include <types/capture.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020082#include <types/filters.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020083#include <types/global.h>
Simon Hormanac821422011-07-15 13:14:09 +090084#include <types/acl.h>
Willy Tarreau3c63fd82011-09-07 18:00:47 +020085#include <types/peers.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020086
Willy Tarreau0fc45a72007-06-17 00:36:03 +020087#include <proto/acl.h>
Willy Tarreau3c595ac2015-04-19 09:59:31 +020088#include <proto/applet.h>
Willy Tarreau2e845be2012-10-19 19:49:09 +020089#include <proto/arg.h>
Willy Tarreau3c595ac2015-04-19 09:59:31 +020090#include <proto/auth.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020091#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020092#include <proto/channel.h>
Willy Tarreauf2943dc2012-10-26 20:10:28 +020093#include <proto/connection.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020094#include <proto/fd.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020095#include <proto/filters.h>
Willy Tarreau34eb6712011-10-24 18:15:04 +020096#include <proto/hdr_idx.h>
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010097#include <proto/hlua.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020098#include <proto/listener.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020099#include <proto/log.h>
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +0100100#include <proto/pattern.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +0200101#include <proto/protocol.h>
Willy Tarreau80587432006-12-24 17:47:20 +0100102#include <proto/proto_http.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200103#include <proto/proxy.h>
104#include <proto/queue.h>
105#include <proto/server.h>
Willy Tarreaub1ec8c42015-04-03 13:53:24 +0200106#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +0200107#include <proto/stream.h>
Willy Tarreau29857942009-05-10 09:01:21 +0200108#include <proto/signal.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200109#include <proto/task.h>
Baptiste Assmann325137d2015-04-13 23:40:55 +0200110#include <proto/dns.h>
Christopher Fauletff2613e2016-11-09 11:36:17 +0100111#include <proto/vars.h>
Willy Tarreau50bc31d2017-08-16 15:35:19 +0200112#ifdef USE_OPENSSL
Grant Zhang872f9c22017-01-21 01:10:18 +0000113#include <proto/ssl_sock.h>
Willy Tarreau50bc31d2017-08-16 15:35:19 +0200114#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +0200115
Willy Tarreau477ecd82010-01-03 21:12:30 +0100116/* list of config files */
117static struct list cfg_cfgfiles = LIST_HEAD_INIT(cfg_cfgfiles);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200118int pid; /* current process id */
Willy Tarreau28156642007-11-26 16:13:36 +0100119int relative_pid = 1; /* process id starting at 1 */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200120
121/* global options */
122struct global global = {
Cyril Bonté203ec5a2017-03-23 22:44:13 +0100123 .hard_stop_after = TICK_ETERNITY,
Willy Tarreau247a13a2012-11-15 17:38:15 +0100124 .nbproc = 1,
William Lallemand5f232402012-04-05 18:02:55 +0200125 .req_count = 0,
William Lallemand0f99e342011-10-12 17:50:54 +0200126 .logsrvs = LIST_HEAD_INIT(global.logsrvs),
William Lallemand9d5f5482012-11-07 16:12:57 +0100127 .maxzlibmem = 0,
William Lallemandd85f9172012-11-09 17:05:39 +0100128 .comp_rate_lim = 0,
Emeric Brun850efd52014-01-29 12:24:34 +0100129 .ssl_server_verify = SSL_SERVER_VERIFY_REQUIRED,
Emeric Bruned760922010-10-22 17:59:25 +0200130 .unix_bind = {
131 .ux = {
132 .uid = -1,
133 .gid = -1,
134 .mode = 0,
135 }
136 },
Willy Tarreau27a674e2009-08-17 07:23:33 +0200137 .tune = {
138 .bufsize = BUFSIZE,
Willy Tarreau27097842015-09-28 13:53:23 +0200139 .maxrewrite = -1,
Willy Tarreau43961d52010-10-04 20:39:20 +0200140 .chksize = BUFSIZE,
Willy Tarreaua24adf02014-11-27 01:11:56 +0100141 .reserved_bufs = RESERVED_BUFS,
Willy Tarreauf3045d22015-04-29 16:24:50 +0200142 .pattern_cache = DEFAULT_PAT_LRU_SIZE,
Emeric Brunfc32aca2012-09-03 12:10:29 +0200143#ifdef USE_OPENSSL
Emeric Brun46635772012-11-14 11:32:56 +0100144 .sslcachesize = SSLCACHESIZE,
Emeric Brunfc32aca2012-09-03 12:10:29 +0200145#endif
William Lallemandf3747832012-11-09 12:33:10 +0100146 .comp_maxlevel = 1,
Willy Tarreau7e312732014-02-12 16:35:14 +0100147#ifdef DEFAULT_IDLE_TIMER
148 .idle_timer = DEFAULT_IDLE_TIMER,
149#else
150 .idle_timer = 1000, /* 1 second */
151#endif
Willy Tarreau27a674e2009-08-17 07:23:33 +0200152 },
Emeric Brun76d88952012-10-05 15:47:31 +0200153#ifdef USE_OPENSSL
154#ifdef DEFAULT_MAXSSLCONN
Willy Tarreau403edff2012-09-06 11:58:37 +0200155 .maxsslconn = DEFAULT_MAXSSLCONN,
156#endif
Emeric Brun76d88952012-10-05 15:47:31 +0200157#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +0200158 /* others NULL OK */
159};
160
161/*********************************************************************/
162
163int stopping; /* non zero means stopping in progress */
Cyril Bonté203ec5a2017-03-23 22:44:13 +0100164int killed; /* non zero means a hard-stop is triggered */
Willy Tarreauaf7ad002010-08-31 15:39:26 +0200165int jobs = 0; /* number of active jobs (conns, listeners, active tasks, ...) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200166
167/* Here we store informations about the pids of the processes we may pause
168 * or kill. We will send them a signal every 10 ms until we can bind to all
169 * our ports. With 200 retries, that's about 2 seconds.
170 */
171#define MAX_START_RETRIES 200
Willy Tarreaubaaee002006-06-26 02:48:02 +0200172static int *oldpids = NULL;
173static int oldpids_sig; /* use USR1 or TERM */
174
Olivier Houchardf73629d2017-04-05 22:33:04 +0200175/* Path to the unix socket we use to retrieve listener sockets from the old process */
176static const char *old_unixsocket;
177
William Lallemand85b0bd92017-06-01 17:38:53 +0200178static char *cur_unixsocket = NULL;
179
William Lallemandcb11fd22017-06-01 17:38:52 +0200180int atexit_flag = 0;
181
Willy Tarreaubb545b42010-08-25 12:58:59 +0200182int nb_oldpids = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200183const int zero = 0;
184const int one = 1;
Alexandre Cassen87ea5482007-10-11 20:48:58 +0200185const struct linger nolinger = { .l_onoff = 1, .l_linger = 0 };
Willy Tarreaubaaee002006-06-26 02:48:02 +0200186
Willy Tarreau1d21e0a2010-03-12 21:58:54 +0100187char hostname[MAX_HOSTNAME_LEN];
Emeric Brun2b920a12010-09-23 18:30:22 +0200188char localpeer[MAX_HOSTNAME_LEN];
Willy Tarreaubaaee002006-06-26 02:48:02 +0200189
Willy Tarreau89efaed2013-12-13 15:14:55 +0100190/* used from everywhere just to drain results we don't want to read and which
191 * recent versions of gcc increasingly and annoyingly complain about.
192 */
193int shut_your_big_mouth_gcc_int = 0;
194
William Lallemand73b85e72017-06-01 17:38:51 +0200195int *children = NULL; /* store PIDs of children in master workers mode */
196
197static volatile sig_atomic_t caught_signal = 0;
198static char **next_argv = NULL;
199
William Lallemande20b6a62017-06-01 17:38:55 +0200200int mworker_pipe[2];
201
Willy Tarreau08ceb102011-07-24 22:58:00 +0200202/* list of the temporarily limited listeners because of lack of resource */
203struct list global_listener_queue = LIST_HEAD_INIT(global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +0200204struct task *global_listener_queue_task;
205static struct task *manage_global_listener_queue(struct task *t);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200206
Willy Tarreauff055502014-04-28 22:27:06 +0200207/* bitfield of a few warnings to emit just once (WARN_*) */
208unsigned int warned = 0;
209
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100210
211/* These are strings to be reported in the output of "haproxy -vv". They may
212 * either be constants (in which case must_free must be zero) or dynamically
213 * allocated strings to pass to free() on exit, and in this case must_free
214 * must be non-zero.
215 */
216struct list build_opts_list = LIST_HEAD_INIT(build_opts_list);
217struct build_opts_str {
218 struct list list;
219 const char *str;
220 int must_free;
221};
222
Willy Tarreaue6945732016-12-21 19:57:00 +0100223/* These functions are called just after the point where the program exits
224 * after a config validity check, so they are generally suited for resource
225 * allocation and slow initializations that should be skipped during basic
226 * config checks. The functions must return 0 on success, or a combination
227 * of ERR_* flags (ERR_WARN, ERR_ABORT, ERR_FATAL, ...). The 2 latter cause
228 * and immediate exit, so the function must have emitted any useful error.
229 */
230struct list post_check_list = LIST_HEAD_INIT(post_check_list);
231struct post_check_fct {
232 struct list list;
233 int (*fct)();
234};
235
Willy Tarreau05554e62016-12-21 20:46:26 +0100236/* These functions are called when freeing the global sections at the end
237 * of deinit, after everything is stopped. They don't return anything, and
238 * they work in best effort mode as their sole goal is to make valgrind
239 * mostly happy.
240 */
241struct list post_deinit_list = LIST_HEAD_INIT(post_deinit_list);
242struct post_deinit_fct {
243 struct list list;
244 void (*fct)();
245};
246
Willy Tarreaubaaee002006-06-26 02:48:02 +0200247/*********************************************************************/
248/* general purpose functions ***************************************/
249/*********************************************************************/
250
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100251/* used to register some build option strings at boot. Set must_free to
252 * non-zero if the string must be freed upon exit.
253 */
254void hap_register_build_opts(const char *str, int must_free)
255{
256 struct build_opts_str *b;
257
258 b = calloc(1, sizeof(*b));
259 if (!b) {
260 fprintf(stderr, "out of memory\n");
261 exit(1);
262 }
263 b->str = str;
264 b->must_free = must_free;
265 LIST_ADDQ(&build_opts_list, &b->list);
266}
267
Willy Tarreaue6945732016-12-21 19:57:00 +0100268/* used to register some initialization functions to call after the checks. */
269void hap_register_post_check(int (*fct)())
270{
271 struct post_check_fct *b;
272
273 b = calloc(1, sizeof(*b));
274 if (!b) {
275 fprintf(stderr, "out of memory\n");
276 exit(1);
277 }
278 b->fct = fct;
279 LIST_ADDQ(&post_check_list, &b->list);
280}
281
Willy Tarreau05554e62016-12-21 20:46:26 +0100282/* used to register some de-initialization functions to call after everything
283 * has stopped.
284 */
285void hap_register_post_deinit(void (*fct)())
286{
287 struct post_deinit_fct *b;
288
289 b = calloc(1, sizeof(*b));
290 if (!b) {
291 fprintf(stderr, "out of memory\n");
292 exit(1);
293 }
294 b->fct = fct;
295 LIST_ADDQ(&post_deinit_list, &b->list);
296}
297
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100298static void display_version()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200299{
300 printf("HA-Proxy version " HAPROXY_VERSION " " HAPROXY_DATE"\n");
Willy Tarreau7b677262017-04-03 09:27:49 +0200301 printf("Copyright 2000-2017 Willy Tarreau <willy@haproxy.org>\n\n");
Willy Tarreaubaaee002006-06-26 02:48:02 +0200302}
303
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100304static void display_build_opts()
Willy Tarreau7b066db2007-12-02 11:28:59 +0100305{
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100306 struct build_opts_str *item;
307
Willy Tarreau7b066db2007-12-02 11:28:59 +0100308 printf("Build options :"
309#ifdef BUILD_TARGET
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100310 "\n TARGET = " BUILD_TARGET
Willy Tarreau7b066db2007-12-02 11:28:59 +0100311#endif
312#ifdef BUILD_CPU
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100313 "\n CPU = " BUILD_CPU
Willy Tarreau7b066db2007-12-02 11:28:59 +0100314#endif
315#ifdef BUILD_CC
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100316 "\n CC = " BUILD_CC
317#endif
318#ifdef BUILD_CFLAGS
319 "\n CFLAGS = " BUILD_CFLAGS
Willy Tarreau7b066db2007-12-02 11:28:59 +0100320#endif
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100321#ifdef BUILD_OPTIONS
322 "\n OPTIONS = " BUILD_OPTIONS
Willy Tarreau7b066db2007-12-02 11:28:59 +0100323#endif
Willy Tarreau27a674e2009-08-17 07:23:33 +0200324 "\n\nDefault settings :"
325 "\n maxconn = %d, bufsize = %d, maxrewrite = %d, maxpollevents = %d"
326 "\n\n",
327 DEFAULT_MAXCONN, BUFSIZE, MAXREWRITE, MAX_POLL_EVENTS);
Willy Tarreaube5b6852009-10-03 18:57:08 +0200328
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100329 list_for_each_entry(item, &build_opts_list, list) {
330 puts(item->str);
331 }
332
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +0100333 putchar('\n');
334
Willy Tarreaube5b6852009-10-03 18:57:08 +0200335 list_pollers(stdout);
336 putchar('\n');
Christopher Fauletb3f4e142016-03-07 12:46:38 +0100337 list_filters(stdout);
338 putchar('\n');
Willy Tarreau7b066db2007-12-02 11:28:59 +0100339}
340
Willy Tarreaubaaee002006-06-26 02:48:02 +0200341/*
342 * This function prints the command line usage and exits
343 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100344static void usage(char *name)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200345{
346 display_version();
347 fprintf(stderr,
Maxime de Roucy379d9c72016-05-13 23:52:56 +0200348 "Usage : %s [-f <cfgfile|cfgdir>]* [ -vdV"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200349 "D ] [ -n <maxconn> ] [ -N <maxpconn> ]\n"
Willy Tarreaua088d312015-10-08 11:58:48 +0200350 " [ -p <pidfile> ] [ -m <max megs> ] [ -C <dir> ] [-- <cfgfile>*]\n"
Willy Tarreau7b066db2007-12-02 11:28:59 +0100351 " -v displays version ; -vv shows known build options.\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200352 " -d enters debug mode ; -db only disables background mode.\n"
Willy Tarreau6e064432012-05-08 15:40:42 +0200353 " -dM[<byte>] poisons memory with <byte> (defaults to 0x50)\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200354 " -V enters verbose mode (disables quiet mode)\n"
Willy Tarreau576132e2011-09-10 19:26:56 +0200355 " -D goes daemon ; -C changes to <dir> before loading files.\n"
William Lallemand095ba4c2017-06-01 17:38:50 +0200356 " -W master-worker mode.\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200357 " -q quiet mode : don't display messages\n"
Willy Tarreau5d01a632009-06-22 16:02:30 +0200358 " -c check mode : only check config files and exit\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200359 " -n sets the maximum total # of connections (%d)\n"
360 " -m limits the usable amount of memory (in MB)\n"
361 " -N sets the default, per-proxy maximum # of connections (%d)\n"
Emeric Brun2b920a12010-09-23 18:30:22 +0200362 " -L set local peer name (default to hostname)\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200363 " -p writes pids of all children to this file\n"
364#if defined(ENABLE_EPOLL)
365 " -de disables epoll() usage even when available\n"
366#endif
Willy Tarreau1e63130a2007-04-09 12:03:06 +0200367#if defined(ENABLE_KQUEUE)
368 " -dk disables kqueue() usage even when available\n"
369#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +0200370#if defined(ENABLE_POLL)
371 " -dp disables poll() usage even when available\n"
372#endif
Willy Tarreaub55932d2009-08-16 13:20:32 +0200373#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3ab68cf2009-01-25 16:03:28 +0100374 " -dS disables splice usage (broken on old kernels)\n"
375#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200376#if defined(USE_GETADDRINFO)
377 " -dG disables getaddrinfo() usage\n"
378#endif
Lukas Tribusa0bcbdc2016-09-12 21:42:20 +0000379#if defined(SO_REUSEPORT)
380 " -dR disables SO_REUSEPORT usage\n"
381#endif
Willy Tarreau3eed10e2016-11-07 21:03:16 +0100382 " -dr ignores server address resolution failures\n"
Emeric Brun850efd52014-01-29 12:24:34 +0100383 " -dV disables SSL verify on servers side\n"
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +0200384 " -sf/-st [pid ]* finishes/terminates old pids.\n"
Olivier Houchardf73629d2017-04-05 22:33:04 +0200385 " -x <unix_socket> get listening sockets from a unix socket\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200386 "\n",
387 name, DEFAULT_MAXCONN, cfg_maxpconn);
388 exit(1);
389}
390
391
392
393/*********************************************************************/
394/* more specific functions ***************************************/
395/*********************************************************************/
396
William Lallemand73b85e72017-06-01 17:38:51 +0200397/* sends the signal <sig> to all pids found in <oldpids>. Returns the number of
398 * pids the signal was correctly delivered to.
399 */
400static int tell_old_pids(int sig)
401{
402 int p;
403 int ret = 0;
404 for (p = 0; p < nb_oldpids; p++)
405 if (kill(oldpids[p], sig) == 0)
406 ret++;
407 return ret;
408}
409
410/* return 1 if a pid is a current child otherwise 0 */
411
412int current_child(int pid)
413{
414 int i;
415
416 for (i = 0; i < global.nbproc; i++) {
417 if (children[i] == pid)
418 return 1;
419 }
420 return 0;
421}
422
423static void mworker_signalhandler(int signum)
424{
425 caught_signal = signum;
426}
427
428static void mworker_register_signals()
429{
430 struct sigaction sa;
431 /* Here we are not using the haproxy async way
432 for signals because it does not exists in
433 the master */
434 memset(&sa, 0, sizeof(struct sigaction));
435 sa.sa_handler = &mworker_signalhandler;
436 sigaction(SIGHUP, &sa, NULL);
437 sigaction(SIGUSR1, &sa, NULL);
438 sigaction(SIGUSR2, &sa, NULL);
439 sigaction(SIGINT, &sa, NULL);
440 sigaction(SIGTERM, &sa, NULL);
441}
442
443static void mworker_block_signals()
444{
445 sigset_t set;
446
447 sigemptyset(&set);
448 sigaddset(&set, SIGUSR1);
449 sigaddset(&set, SIGUSR2);
450 sigaddset(&set, SIGHUP);
451 sigaddset(&set, SIGINT);
452 sigaddset(&set, SIGTERM);
453 sigprocmask(SIG_SETMASK, &set, NULL);
454}
455
456static void mworker_unblock_signals()
457{
458 sigset_t set;
459
460 sigemptyset(&set);
461 sigaddset(&set, SIGUSR1);
462 sigaddset(&set, SIGUSR2);
463 sigaddset(&set, SIGHUP);
464 sigaddset(&set, SIGINT);
465 sigaddset(&set, SIGTERM);
466 sigprocmask(SIG_UNBLOCK, &set, NULL);
467}
468
469static void mworker_unregister_signals()
470{
471 signal(SIGINT, SIG_DFL);
472 signal(SIGTERM, SIG_DFL);
473 signal(SIGHUP, SIG_IGN);
474 signal(SIGUSR1, SIG_IGN);
475 signal(SIGUSR2, SIG_IGN);
476}
477
478/*
479 * Send signal to every known children.
480 */
481
482static void mworker_kill(int sig)
483{
484 int i;
485
486 tell_old_pids(sig);
487 if (children) {
488 for (i = 0; i < global.nbproc; i++)
489 kill(children[i], sig);
490 }
491}
492
Willy Tarreaubaaee002006-06-26 02:48:02 +0200493/*
William Lallemand73b85e72017-06-01 17:38:51 +0200494 * remove a pid forom the olpid array and decrease nb_oldpids
495 * return 1 pid was found otherwise return 0
496 */
497
498int delete_oldpid(int pid)
499{
500 int i;
501
502 for (i = 0; i < nb_oldpids; i++) {
503 if (oldpids[i] == pid) {
504 oldpids[i] = oldpids[nb_oldpids - 1];
505 oldpids[nb_oldpids - 1] = 0;
506 nb_oldpids--;
507 return 1;
508 }
509 }
510 return 0;
511}
512
William Lallemand85b0bd92017-06-01 17:38:53 +0200513
514static void get_cur_unixsocket()
515{
516 /* if -x was used, try to update the stat socket if not available anymore */
517 if (global.stats_fe) {
518 struct bind_conf *bind_conf;
519
520 /* pass through all stats socket */
521 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
522 struct listener *l;
523
524 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
525
526 if (l->addr.ss_family == AF_UNIX &&
527 (bind_conf->level & ACCESS_FD_LISTENERS)) {
528 const struct sockaddr_un *un;
529
530 un = (struct sockaddr_un *)&l->addr;
531 /* priority to old_unixsocket */
532 if (!cur_unixsocket) {
533 cur_unixsocket = strdup(un->sun_path);
534 } else {
535 if (old_unixsocket && !strcmp(un->sun_path, old_unixsocket)) {
536 free(cur_unixsocket);
537 cur_unixsocket = strdup(old_unixsocket);
538 return;
539 }
540 }
541 }
542 }
543 }
544 }
545 if (!cur_unixsocket && old_unixsocket)
546 cur_unixsocket = strdup(old_unixsocket);
547}
548
William Lallemand73b85e72017-06-01 17:38:51 +0200549/*
550 * When called, this function reexec haproxy with -sf followed by current
551 * children PIDs and possibily old children PIDs if they didn't leave yet.
552 */
553static void mworker_reload()
554{
555 int next_argc = 0;
556 int j;
557 char *msg = NULL;
558
559 mworker_block_signals();
560 mworker_unregister_signals();
561 setenv("HAPROXY_MWORKER_REEXEC", "1", 1);
562
563 /* compute length */
564 while (next_argv[next_argc])
565 next_argc++;
566
William Lallemand85b0bd92017-06-01 17:38:53 +0200567 /* 1 for haproxy -sf, 2 for -x /socket */
568 next_argv = realloc(next_argv, (next_argc + 1 + 2 + global.nbproc + nb_oldpids + 1) * sizeof(char *));
William Lallemand73b85e72017-06-01 17:38:51 +0200569 if (next_argv == NULL)
570 goto alloc_error;
571
572
573 /* add -sf <PID>* to argv */
574 if (children || nb_oldpids > 0)
575 next_argv[next_argc++] = "-sf";
576 if (children) {
577 for (j = 0; j < global.nbproc; next_argc++,j++) {
578 next_argv[next_argc] = memprintf(&msg, "%d", children[j]);
579 if (next_argv[next_argc] == NULL)
580 goto alloc_error;
581 msg = NULL;
582 }
583 }
584 /* copy old process PIDs */
585 for (j = 0; j < nb_oldpids; next_argc++,j++) {
586 next_argv[next_argc] = memprintf(&msg, "%d", oldpids[j]);
587 if (next_argv[next_argc] == NULL)
588 goto alloc_error;
589 msg = NULL;
590 }
591 next_argv[next_argc] = NULL;
William Lallemand85b0bd92017-06-01 17:38:53 +0200592
William Lallemand2bf6d622017-06-20 11:20:23 +0200593 /* add the -x option with the stat socket */
William Lallemand85b0bd92017-06-01 17:38:53 +0200594 if (cur_unixsocket) {
595
William Lallemand2bf6d622017-06-20 11:20:23 +0200596 next_argv[next_argc++] = "-x";
597 next_argv[next_argc++] = (char *)cur_unixsocket;
598 next_argv[next_argc++] = NULL;
William Lallemand85b0bd92017-06-01 17:38:53 +0200599 }
600
William Lallemand73b85e72017-06-01 17:38:51 +0200601 deinit(); /* we don't want to leak FD there */
602 Warning("Reexecuting Master process\n");
603 execv(next_argv[0], next_argv);
604
605alloc_error:
606 Warning("Cannot allocate memory\n");
607 Warning("Failed to reexecute the master processs [%d]\n", pid);
608 return;
609}
610
611
612/*
613 * Wait for every children to exit
614 */
615
616static void mworker_wait()
617{
618 int exitpid = -1;
619 int status = 0;
620
621 mworker_register_signals();
622 mworker_unblock_signals();
623
624 while (1) {
625
626 while (((exitpid = wait(&status)) == -1) && errno == EINTR) {
627 int sig = caught_signal;
628 if (sig == SIGUSR2 || sig == SIGHUP) {
629 mworker_reload();
630 } else {
631 Warning("Exiting Master process...\n");
632 mworker_kill(sig);
633 mworker_unregister_signals();
634 }
635 caught_signal = 0;
636 }
637
638 if (exitpid == -1 && errno == ECHILD) {
639 Warning("All workers are left. Leaving... (%d)\n", status);
William Lallemandcb11fd22017-06-01 17:38:52 +0200640 atexit_flag = 0;
William Lallemand73b85e72017-06-01 17:38:51 +0200641 exit(status); /* parent must leave using the latest status code known */
642 }
643
644 if (WIFEXITED(status))
645 status = WEXITSTATUS(status);
646 else if (WIFSIGNALED(status))
647 status = 128 + WTERMSIG(status);
648 else if (WIFSTOPPED(status))
649 status = 128 + WSTOPSIG(status);
650 else
651 status = 255;
652
653 if (!children) {
654 Warning("Worker %d left with exit code %d\n", exitpid, status);
655 } else {
656 /* check if exited child was in the current children list */
657 if (current_child(exitpid)) {
658 Alert("Current worker %d left with exit code %d\n", exitpid, status);
William Lallemand69f9b3b2017-06-01 17:38:54 +0200659 if (status != 0 && status != 130 && status != 143
660 && global.tune.options & GTUNE_EXIT_ONFAILURE) {
661 Alert("exit-on-failure: killing every workers with SIGTERM\n");
662 mworker_kill(SIGTERM);
663 }
William Lallemand73b85e72017-06-01 17:38:51 +0200664 } else {
665 Warning("Former worker %d left with exit code %d\n", exitpid, status);
666 delete_oldpid(exitpid);
667 }
668 }
669 }
670}
671
William Lallemandcb11fd22017-06-01 17:38:52 +0200672
673/*
674 * Reexec the process in failure mode, instead of exiting
675 */
676void reexec_on_failure()
677{
678 if (!atexit_flag)
679 return;
680
681 setenv("HAPROXY_MWORKER_WAIT_ONLY", "1", 1);
682
683 Warning("Reexecuting Master process in waitpid mode\n");
684 mworker_reload();
685
686 Warning("Failed to reexecute the master processs\n");
687}
William Lallemand73b85e72017-06-01 17:38:51 +0200688
689
690/*
Willy Tarreaud0807c32010-08-27 18:26:11 +0200691 * upon SIGUSR1, let's have a soft stop. Note that soft_stop() broadcasts
692 * a signal zero to all subscribers. This means that it's as easy as
693 * subscribing to signal 0 to get informed about an imminent shutdown.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200694 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100695static void sig_soft_stop(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200696{
697 soft_stop();
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200698 signal_unregister_handler(sh);
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200699 pool_gc2();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200700}
701
702/*
703 * upon SIGTTOU, we pause everything
704 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100705static void sig_pause(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200706{
707 pause_proxies();
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200708 pool_gc2();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200709}
710
711/*
712 * upon SIGTTIN, let's have a soft stop.
713 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100714static void sig_listen(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200715{
Willy Tarreaube58c382011-07-24 18:28:10 +0200716 resume_proxies();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200717}
718
719/*
720 * this function dumps every server's state when the process receives SIGHUP.
721 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100722static void sig_dump_state(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200723{
724 struct proxy *p = proxy;
725
726 Warning("SIGHUP received, dumping servers states.\n");
727 while (p) {
728 struct server *s = p->srv;
729
730 send_log(p, LOG_NOTICE, "SIGHUP received, dumping servers states for proxy %s.\n", p->id);
731 while (s) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100732 chunk_printf(&trash,
733 "SIGHUP: Server %s/%s is %s. Conn: %d act, %d pend, %lld tot.",
734 p->id, s->id,
Emeric Brun52a91d32017-08-31 14:41:55 +0200735 (s->cur_state != SRV_ST_STOPPED) ? "UP" : "DOWN",
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100736 s->cur_sess, s->nbpend, s->counters.cum_sess);
737 Warning("%s\n", trash.str);
738 send_log(p, LOG_NOTICE, "%s\n", trash.str);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200739 s = s->next;
740 }
741
Willy Tarreau5fcc8f12007-09-17 11:27:09 +0200742 /* FIXME: those info are a bit outdated. We should be able to distinguish between FE and BE. */
743 if (!p->srv) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100744 chunk_printf(&trash,
745 "SIGHUP: Proxy %s has no servers. Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
746 p->id,
747 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
Willy Tarreau5fcc8f12007-09-17 11:27:09 +0200748 } else if (p->srv_act == 0) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100749 chunk_printf(&trash,
750 "SIGHUP: Proxy %s %s ! Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
751 p->id,
752 (p->srv_bck) ? "is running on backup servers" : "has no server available",
753 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200754 } else {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100755 chunk_printf(&trash,
756 "SIGHUP: Proxy %s has %d active servers and %d backup servers available."
757 " Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
758 p->id, p->srv_act, p->srv_bck,
759 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200760 }
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100761 Warning("%s\n", trash.str);
762 send_log(p, LOG_NOTICE, "%s\n", trash.str);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200763
764 p = p->next;
765 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200766}
767
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100768static void dump(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200769{
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200770 /* dump memory usage then free everything possible */
771 dump_pools();
772 pool_gc2();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200773}
774
Maxime de Roucy379d9c72016-05-13 23:52:56 +0200775/* This function check if cfg_cfgfiles containes directories.
776 * If it find one, it add all the files (and only files) it containes
777 * in cfg_cfgfiles in place of the directory (and remove the directory).
778 * It add the files in lexical order.
779 * It add only files with .cfg extension.
780 * It doesn't add files with name starting with '.'
781 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100782static void cfgfiles_expand_directories(void)
Maxime de Roucy379d9c72016-05-13 23:52:56 +0200783{
784 struct wordlist *wl, *wlb;
785 char *err = NULL;
786
787 list_for_each_entry_safe(wl, wlb, &cfg_cfgfiles, list) {
788 struct stat file_stat;
789 struct dirent **dir_entries = NULL;
790 int dir_entries_nb;
791 int dir_entries_it;
792
793 if (stat(wl->s, &file_stat)) {
794 Alert("Cannot open configuration file/directory %s : %s\n",
795 wl->s,
796 strerror(errno));
797 exit(1);
798 }
799
800 if (!S_ISDIR(file_stat.st_mode))
801 continue;
802
803 /* from this point wl->s is a directory */
804
805 dir_entries_nb = scandir(wl->s, &dir_entries, NULL, alphasort);
806 if (dir_entries_nb < 0) {
807 Alert("Cannot open configuration directory %s : %s\n",
808 wl->s,
809 strerror(errno));
810 exit(1);
811 }
812
813 /* for each element in the directory wl->s */
814 for (dir_entries_it = 0; dir_entries_it < dir_entries_nb; dir_entries_it++) {
815 struct dirent *dir_entry = dir_entries[dir_entries_it];
816 char *filename = NULL;
817 char *d_name_cfgext = strstr(dir_entry->d_name, ".cfg");
818
819 /* don't add filename that begin with .
820 * only add filename with .cfg extention
821 */
822 if (dir_entry->d_name[0] == '.' ||
823 !(d_name_cfgext && d_name_cfgext[4] == '\0'))
824 goto next_dir_entry;
825
826 if (!memprintf(&filename, "%s/%s", wl->s, dir_entry->d_name)) {
827 Alert("Cannot load configuration files %s : out of memory.\n",
828 filename);
829 exit(1);
830 }
831
832 if (stat(filename, &file_stat)) {
833 Alert("Cannot open configuration file %s : %s\n",
834 wl->s,
835 strerror(errno));
836 exit(1);
837 }
838
839 /* don't add anything else than regular file in cfg_cfgfiles
840 * this way we avoid loops
841 */
842 if (!S_ISREG(file_stat.st_mode))
843 goto next_dir_entry;
844
845 if (!list_append_word(&wl->list, filename, &err)) {
846 Alert("Cannot load configuration files %s : %s\n",
847 filename,
848 err);
849 exit(1);
850 }
851
852next_dir_entry:
853 free(filename);
854 free(dir_entry);
855 }
856
857 free(dir_entries);
858
859 /* remove the current directory (wl) from cfg_cfgfiles */
860 free(wl->s);
861 LIST_DEL(&wl->list);
862 free(wl);
863 }
864
865 free(err);
866}
867
Olivier Houchardf73629d2017-04-05 22:33:04 +0200868static int get_old_sockets(const char *unixsocket)
869{
870 char *cmsgbuf = NULL, *tmpbuf = NULL;
871 int *tmpfd = NULL;
872 struct sockaddr_un addr;
873 struct cmsghdr *cmsg;
874 struct msghdr msghdr;
875 struct iovec iov;
876 struct xfer_sock_list *xfer_sock = NULL;
Olivier Houchard54740872017-04-06 14:45:14 +0200877 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf73629d2017-04-05 22:33:04 +0200878 int sock = -1;
879 int ret = -1;
880 int ret2 = -1;
881 int fd_nb;
882 int got_fd = 0;
883 int i = 0;
884 size_t maxoff = 0, curoff = 0;
885
886 memset(&msghdr, 0, sizeof(msghdr));
887 cmsgbuf = malloc(CMSG_SPACE(sizeof(int)) * MAX_SEND_FD);
888 if (!cmsgbuf) {
889 Warning("Failed to allocate memory to send sockets\n");
890 goto out;
891 }
892 sock = socket(PF_UNIX, SOCK_STREAM, 0);
893 if (sock < 0) {
894 Warning("Failed to connect to the old process socket '%s'\n",
895 unixsocket);
896 goto out;
897 }
898 strncpy(addr.sun_path, unixsocket, sizeof(addr.sun_path));
899 addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
900 addr.sun_family = PF_UNIX;
901 ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
902 if (ret < 0) {
903 Warning("Failed to connect to the old process socket '%s'\n",
904 unixsocket);
905 goto out;
906 }
Olivier Houchard54740872017-04-06 14:45:14 +0200907 setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf73629d2017-04-05 22:33:04 +0200908 iov.iov_base = &fd_nb;
909 iov.iov_len = sizeof(fd_nb);
910 msghdr.msg_iov = &iov;
911 msghdr.msg_iovlen = 1;
912 send(sock, "_getsocks\n", strlen("_getsocks\n"), 0);
913 /* First, get the number of file descriptors to be received */
914 if (recvmsg(sock, &msghdr, MSG_WAITALL) != sizeof(fd_nb)) {
915 Warning("Failed to get the number of sockets to be transferred !\n");
916 goto out;
917 }
918 if (fd_nb == 0) {
919 ret = 0;
920 goto out;
921 }
922 tmpbuf = malloc(fd_nb * (1 + NAME_MAX + 1 + IFNAMSIZ + sizeof(int)));
923 if (tmpbuf == NULL) {
924 Warning("Failed to allocate memory while receiving sockets\n");
925 goto out;
926 }
927 tmpfd = malloc(fd_nb * sizeof(int));
928 if (tmpfd == NULL) {
929 Warning("Failed to allocate memory while receiving sockets\n");
930 goto out;
931 }
932 msghdr.msg_control = cmsgbuf;
933 msghdr.msg_controllen = CMSG_SPACE(sizeof(int)) * MAX_SEND_FD;
934 iov.iov_len = MAX_SEND_FD * (1 + NAME_MAX + 1 + IFNAMSIZ + sizeof(int));
935 do {
936 int ret3;
937
938 iov.iov_base = tmpbuf + curoff;
939 ret = recvmsg(sock, &msghdr, 0);
940 if (ret == -1 && errno == EINTR)
941 continue;
942 if (ret <= 0)
943 break;
944 /* Send an ack to let the sender know we got the sockets
945 * and it can send some more
946 */
947 do {
948 ret3 = send(sock, &got_fd, sizeof(got_fd), 0);
949 } while (ret3 == -1 && errno == EINTR);
950 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg != NULL;
951 cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
952 if (cmsg->cmsg_level == SOL_SOCKET &&
953 cmsg->cmsg_type == SCM_RIGHTS) {
954 size_t totlen = cmsg->cmsg_len -
955 CMSG_LEN(0);
956 if (totlen / sizeof(int) + got_fd > fd_nb) {
957 Warning("Got to many sockets !\n");
958 goto out;
959 }
960 /*
961 * Be paranoid and use memcpy() to avoid any
962 * potential alignement issue.
963 */
964 memcpy(&tmpfd[got_fd], CMSG_DATA(cmsg), totlen);
965 got_fd += totlen / sizeof(int);
966 }
967 }
968 curoff += ret;
969 } while (got_fd < fd_nb);
970
971 if (got_fd != fd_nb) {
972 Warning("We didn't get the expected number of sockets (expecting %d got %d)\n",
973 fd_nb, got_fd);
974 goto out;
975 }
976 maxoff = curoff;
977 curoff = 0;
978 for (i = 0; i < got_fd; i++) {
979 int fd = tmpfd[i];
980 socklen_t socklen;
981 int len;
982
983 xfer_sock = calloc(1, sizeof(*xfer_sock));
984 if (!xfer_sock) {
985 Warning("Failed to allocate memory in get_old_sockets() !\n");
986 break;
987 }
988 xfer_sock->fd = -1;
989
990 socklen = sizeof(xfer_sock->addr);
991 if (getsockname(fd, (struct sockaddr *)&xfer_sock->addr, &socklen) != 0) {
992 Warning("Failed to get socket address\n");
993 free(xfer_sock);
Olivier Houchardbe7b1ce2017-07-17 17:25:33 +0200994 xfer_sock = NULL;
Olivier Houchardf73629d2017-04-05 22:33:04 +0200995 continue;
996 }
997 if (curoff >= maxoff) {
998 Warning("Inconsistency while transferring sockets\n");
999 goto out;
1000 }
1001 len = tmpbuf[curoff++];
1002 if (len > 0) {
1003 /* We have a namespace */
1004 if (curoff + len > maxoff) {
1005 Warning("Inconsistency while transferring sockets\n");
1006 goto out;
1007 }
1008 xfer_sock->namespace = malloc(len + 1);
1009 if (!xfer_sock->namespace) {
1010 Warning("Failed to allocate memory while transferring sockets\n");
1011 goto out;
1012 }
1013 memcpy(xfer_sock->namespace, &tmpbuf[curoff], len);
1014 xfer_sock->namespace[len] = 0;
1015 curoff += len;
1016 }
1017 if (curoff >= maxoff) {
1018 Warning("Inconsistency while transferring sockets\n");
1019 goto out;
1020 }
1021 len = tmpbuf[curoff++];
1022 if (len > 0) {
1023 /* We have an interface */
1024 if (curoff + len > maxoff) {
1025 Warning("Inconsistency while transferring sockets\n");
1026 goto out;
1027 }
1028 xfer_sock->iface = malloc(len + 1);
1029 if (!xfer_sock->iface) {
1030 Warning("Failed to allocate memory while transferring sockets\n");
1031 goto out;
1032 }
1033 memcpy(xfer_sock->iface, &tmpbuf[curoff], len);
1034 xfer_sock->namespace[len] = 0;
1035 curoff += len;
1036 }
1037 if (curoff + sizeof(int) > maxoff) {
1038 Warning("Inconsistency while transferring sockets\n");
1039 goto out;
1040 }
1041 memcpy(&xfer_sock->options, &tmpbuf[curoff],
1042 sizeof(xfer_sock->options));
1043 curoff += sizeof(xfer_sock->options);
1044
1045 xfer_sock->fd = fd;
1046 if (xfer_sock_list)
1047 xfer_sock_list->prev = xfer_sock;
1048 xfer_sock->next = xfer_sock_list;
1049 xfer_sock->prev = NULL;
1050 xfer_sock_list = xfer_sock;
1051 xfer_sock = NULL;
1052 }
1053
1054 ret2 = 0;
1055out:
1056 /* If we failed midway make sure to close the remaining
1057 * file descriptors
1058 */
1059 if (tmpfd != NULL && i < got_fd) {
1060 for (; i < got_fd; i++) {
1061 close(tmpfd[i]);
1062 }
1063 }
1064 free(tmpbuf);
1065 free(tmpfd);
1066 free(cmsgbuf);
1067 if (sock != -1)
1068 close(sock);
1069 if (xfer_sock) {
1070 free(xfer_sock->namespace);
1071 free(xfer_sock->iface);
1072 if (xfer_sock->fd != -1)
1073 close(xfer_sock->fd);
1074 free(xfer_sock);
1075 }
1076 return (ret2);
1077}
1078
Willy Tarreaubaaee002006-06-26 02:48:02 +02001079/*
William Lallemand73b85e72017-06-01 17:38:51 +02001080 * copy and cleanup the current argv
1081 * Remove the -sf /-st parameters
1082 * Return an allocated copy of argv
1083 */
1084
1085static char **copy_argv(int argc, char **argv)
1086{
1087 char **newargv;
William Lallemand2bf6d622017-06-20 11:20:23 +02001088 int i = 0, j = 0;
William Lallemand73b85e72017-06-01 17:38:51 +02001089
1090 newargv = calloc(argc + 2, sizeof(char *));
1091 if (newargv == NULL) {
1092 Warning("Cannot allocate memory\n");
1093 return NULL;
1094 }
1095
William Lallemand2bf6d622017-06-20 11:20:23 +02001096 while (i < argc) {
1097 /* -sf or -st or -x */
1098 if ((argv[i][1] == 's' && (argv[i][2] == 'f' || argv[i][2] == 't')) || argv[i][1] == 'x' ) {
1099 /* list of pids to finish ('f') or terminate ('t') or unix socket (-x) */
William Lallemand73b85e72017-06-01 17:38:51 +02001100 i++;
1101 while (i < argc && argv[i][0] != '-') {
1102 i++;
1103 }
William Lallemand2bf6d622017-06-20 11:20:23 +02001104 continue;
William Lallemand73b85e72017-06-01 17:38:51 +02001105 }
William Lallemand2bf6d622017-06-20 11:20:23 +02001106
1107 newargv[j++] = argv[i++];
William Lallemand73b85e72017-06-01 17:38:51 +02001108 }
William Lallemand2bf6d622017-06-20 11:20:23 +02001109
William Lallemand73b85e72017-06-01 17:38:51 +02001110 return newargv;
1111}
1112
1113/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001114 * This function initializes all the necessary variables. It only returns
1115 * if everything is OK. If something fails, it exits.
1116 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +01001117static void init(int argc, char **argv)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001118{
Willy Tarreaubaaee002006-06-26 02:48:02 +02001119 int arg_mode = 0; /* MODE_DEBUG, ... */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001120 char *tmp;
1121 char *cfg_pidfile = NULL;
Willy Tarreau058e9072009-07-20 09:30:05 +02001122 int err_code = 0;
Maxime de Roucy0f503922016-05-13 23:52:55 +02001123 char *err_msg = NULL;
Willy Tarreau477ecd82010-01-03 21:12:30 +01001124 struct wordlist *wl;
Kevinm48936af2010-12-22 16:08:21 +00001125 char *progname;
Willy Tarreau576132e2011-09-10 19:26:56 +02001126 char *change_dir = NULL;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001127 struct proxy *px;
Willy Tarreaue6945732016-12-21 19:57:00 +01001128 struct post_check_fct *pcf;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001129
William Lallemand73b85e72017-06-01 17:38:51 +02001130 next_argv = copy_argv(argc, argv);
1131
Christopher Faulet748919a2017-07-26 14:59:46 +02001132 if (!init_trash_buffers()) {
1133 Alert("failed to initialize trash buffers.\n");
1134 exit(1);
1135 }
David du Colombier7af46052012-05-16 14:16:48 +02001136
Emeric Brun2b920a12010-09-23 18:30:22 +02001137 /* NB: POSIX does not make it mandatory for gethostname() to NULL-terminate
1138 * the string in case of truncation, and at least FreeBSD appears not to do
1139 * it.
1140 */
1141 memset(hostname, 0, sizeof(hostname));
1142 gethostname(hostname, sizeof(hostname) - 1);
1143 memset(localpeer, 0, sizeof(localpeer));
1144 memcpy(localpeer, hostname, (sizeof(hostname) > sizeof(localpeer) ? sizeof(localpeer) : sizeof(hostname)) - 1);
1145
Willy Tarreaubaaee002006-06-26 02:48:02 +02001146 /*
1147 * Initialize the previously static variables.
1148 */
1149
Willy Tarreau3eba98a2009-01-25 13:56:13 +01001150 totalconn = actconn = maxfd = listeners = stopping = 0;
Cyril Bonté203ec5a2017-03-23 22:44:13 +01001151 killed = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001152
1153
1154#ifdef HAPROXY_MEMMAX
Willy Tarreau70060452015-12-14 12:46:07 +01001155 global.rlimit_memmax_all = HAPROXY_MEMMAX;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001156#endif
1157
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001158 tzset();
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02001159 tv_update_date(-1,-1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001160 start_date = now;
1161
Willy Tarreau84310e22014-02-14 11:59:04 +01001162 srandom(now_ms - getpid());
1163
Dragan Dosen835b9212016-02-12 13:23:03 +01001164 init_log();
Willy Tarreau29857942009-05-10 09:01:21 +02001165 signal_init();
Willy Tarreau8ed669b2013-01-11 15:49:37 +01001166 if (init_acl() != 0)
1167 exit(1);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +02001168 init_task();
Willy Tarreau87b09662015-04-03 00:22:06 +02001169 init_stream();
Willy Tarreaub1ec8c42015-04-03 13:53:24 +02001170 init_session();
Willy Tarreauf2943dc2012-10-26 20:10:28 +02001171 init_connection();
Willy Tarreau8280d642009-09-23 23:37:52 +02001172 /* warning, we init buffers later */
Willy Tarreaue4d7e552007-05-13 20:19:55 +02001173 init_pendconn();
Willy Tarreau80587432006-12-24 17:47:20 +01001174 init_proto_http();
Willy Tarreaubaaee002006-06-26 02:48:02 +02001175
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01001176 /* Initialise lua. */
1177 hlua_init();
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01001178
Christopher Fauletff2613e2016-11-09 11:36:17 +01001179 /* Initialize process vars */
1180 vars_init(&global.vars, SCOPE_PROC);
1181
Willy Tarreau43b78992009-01-25 15:42:27 +01001182 global.tune.options |= GTUNE_USE_SELECT; /* select() is always available */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001183#if defined(ENABLE_POLL)
Willy Tarreau43b78992009-01-25 15:42:27 +01001184 global.tune.options |= GTUNE_USE_POLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001185#endif
1186#if defined(ENABLE_EPOLL)
Willy Tarreau43b78992009-01-25 15:42:27 +01001187 global.tune.options |= GTUNE_USE_EPOLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001188#endif
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001189#if defined(ENABLE_KQUEUE)
Willy Tarreau43b78992009-01-25 15:42:27 +01001190 global.tune.options |= GTUNE_USE_KQUEUE;
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001191#endif
Willy Tarreaub55932d2009-08-16 13:20:32 +02001192#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3ab68cf2009-01-25 16:03:28 +01001193 global.tune.options |= GTUNE_USE_SPLICE;
1194#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +02001195#if defined(USE_GETADDRINFO)
1196 global.tune.options |= GTUNE_USE_GAI;
1197#endif
Lukas Tribusa0bcbdc2016-09-12 21:42:20 +00001198#if defined(SO_REUSEPORT)
1199 global.tune.options |= GTUNE_USE_REUSEPORT;
1200#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +02001201
1202 pid = getpid();
1203 progname = *argv;
1204 while ((tmp = strchr(progname, '/')) != NULL)
1205 progname = tmp + 1;
1206
Kevinm48936af2010-12-22 16:08:21 +00001207 /* the process name is used for the logs only */
Dragan Dosen43885c72015-10-01 13:18:13 +02001208 chunk_initstr(&global.log_tag, strdup(progname));
Kevinm48936af2010-12-22 16:08:21 +00001209
Willy Tarreaubaaee002006-06-26 02:48:02 +02001210 argc--; argv++;
1211 while (argc > 0) {
1212 char *flag;
1213
1214 if (**argv == '-') {
1215 flag = *argv+1;
1216
1217 /* 1 arg */
1218 if (*flag == 'v') {
1219 display_version();
Willy Tarreau7b066db2007-12-02 11:28:59 +01001220 if (flag[1] == 'v') /* -vv */
1221 display_build_opts();
Willy Tarreaubaaee002006-06-26 02:48:02 +02001222 exit(0);
1223 }
1224#if defined(ENABLE_EPOLL)
1225 else if (*flag == 'd' && flag[1] == 'e')
Willy Tarreau43b78992009-01-25 15:42:27 +01001226 global.tune.options &= ~GTUNE_USE_EPOLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001227#endif
1228#if defined(ENABLE_POLL)
1229 else if (*flag == 'd' && flag[1] == 'p')
Willy Tarreau43b78992009-01-25 15:42:27 +01001230 global.tune.options &= ~GTUNE_USE_POLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001231#endif
Willy Tarreau69cad1a2007-04-10 22:45:11 +02001232#if defined(ENABLE_KQUEUE)
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001233 else if (*flag == 'd' && flag[1] == 'k')
Willy Tarreau43b78992009-01-25 15:42:27 +01001234 global.tune.options &= ~GTUNE_USE_KQUEUE;
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001235#endif
Willy Tarreaub55932d2009-08-16 13:20:32 +02001236#if defined(CONFIG_HAP_LINUX_SPLICE)
Willy Tarreau3ab68cf2009-01-25 16:03:28 +01001237 else if (*flag == 'd' && flag[1] == 'S')
1238 global.tune.options &= ~GTUNE_USE_SPLICE;
1239#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +02001240#if defined(USE_GETADDRINFO)
1241 else if (*flag == 'd' && flag[1] == 'G')
1242 global.tune.options &= ~GTUNE_USE_GAI;
1243#endif
Lukas Tribusa0bcbdc2016-09-12 21:42:20 +00001244#if defined(SO_REUSEPORT)
1245 else if (*flag == 'd' && flag[1] == 'R')
1246 global.tune.options &= ~GTUNE_USE_REUSEPORT;
1247#endif
Emeric Brun850efd52014-01-29 12:24:34 +01001248 else if (*flag == 'd' && flag[1] == 'V')
1249 global.ssl_server_verify = SSL_SERVER_VERIFY_NONE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001250 else if (*flag == 'V')
1251 arg_mode |= MODE_VERBOSE;
1252 else if (*flag == 'd' && flag[1] == 'b')
1253 arg_mode |= MODE_FOREGROUND;
Willy Tarreau6e064432012-05-08 15:40:42 +02001254 else if (*flag == 'd' && flag[1] == 'M')
1255 mem_poison_byte = flag[2] ? strtol(flag + 2, NULL, 0) : 'P';
Willy Tarreau3eed10e2016-11-07 21:03:16 +01001256 else if (*flag == 'd' && flag[1] == 'r')
1257 global.tune.options |= GTUNE_RESOLVE_DONTFAIL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001258 else if (*flag == 'd')
1259 arg_mode |= MODE_DEBUG;
1260 else if (*flag == 'c')
1261 arg_mode |= MODE_CHECK;
William Lallemand095ba4c2017-06-01 17:38:50 +02001262 else if (*flag == 'D')
Willy Tarreau6bde87b2009-05-18 16:29:51 +02001263 arg_mode |= MODE_DAEMON;
William Lallemand095ba4c2017-06-01 17:38:50 +02001264 else if (*flag == 'W')
1265 arg_mode |= MODE_MWORKER;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001266 else if (*flag == 'q')
1267 arg_mode |= MODE_QUIET;
Olivier Houchardf73629d2017-04-05 22:33:04 +02001268 else if (*flag == 'x') {
William Lallemand45eff442017-06-19 15:57:55 +02001269 if (argc <= 1 || argv[1][0] == '-') {
1270 Alert("Unix socket path expected with the -x flag\n\n");
1271 usage(progname);
Olivier Houchardf73629d2017-04-05 22:33:04 +02001272 }
William Lallemand4fc09692017-06-19 16:37:19 +02001273 if (old_unixsocket)
1274 Warning("-x option already set, overwriting the value\n");
Olivier Houchardf73629d2017-04-05 22:33:04 +02001275 old_unixsocket = argv[1];
William Lallemand4fc09692017-06-19 16:37:19 +02001276
Olivier Houchardf73629d2017-04-05 22:33:04 +02001277 argv++;
1278 argc--;
1279 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001280 else if (*flag == 's' && (flag[1] == 'f' || flag[1] == 't')) {
1281 /* list of pids to finish ('f') or terminate ('t') */
1282
1283 if (flag[1] == 'f')
1284 oldpids_sig = SIGUSR1; /* finish then exit */
1285 else
1286 oldpids_sig = SIGTERM; /* terminate immediately */
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001287 while (argc > 1 && argv[1][0] != '-') {
1288 oldpids = realloc(oldpids, (nb_oldpids + 1) * sizeof(int));
1289 if (!oldpids) {
1290 Alert("Cannot allocate old pid : out of memory.\n");
1291 exit(1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001292 }
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001293 argc--; argv++;
1294 oldpids[nb_oldpids] = atol(*argv);
1295 if (oldpids[nb_oldpids] <= 0)
1296 usage(progname);
1297 nb_oldpids++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001298 }
1299 }
Willy Tarreaua088d312015-10-08 11:58:48 +02001300 else if (flag[0] == '-' && flag[1] == 0) { /* "--" */
1301 /* now that's a cfgfile list */
1302 argv++; argc--;
1303 while (argc > 0) {
Maxime de Roucy0f503922016-05-13 23:52:55 +02001304 if (!list_append_word(&cfg_cfgfiles, *argv, &err_msg)) {
1305 Alert("Cannot load configuration file/directory %s : %s\n",
1306 *argv,
1307 err_msg);
Willy Tarreaua088d312015-10-08 11:58:48 +02001308 exit(1);
1309 }
Willy Tarreaua088d312015-10-08 11:58:48 +02001310 argv++; argc--;
1311 }
1312 break;
1313 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001314 else { /* >=2 args */
1315 argv++; argc--;
1316 if (argc == 0)
Willy Tarreau3bafcdc2011-09-10 19:20:23 +02001317 usage(progname);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001318
1319 switch (*flag) {
Willy Tarreau576132e2011-09-10 19:26:56 +02001320 case 'C' : change_dir = *argv; break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001321 case 'n' : cfg_maxconn = atol(*argv); break;
Willy Tarreau70060452015-12-14 12:46:07 +01001322 case 'm' : global.rlimit_memmax_all = atol(*argv); break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001323 case 'N' : cfg_maxpconn = atol(*argv); break;
Emeric Brun2b920a12010-09-23 18:30:22 +02001324 case 'L' : strncpy(localpeer, *argv, sizeof(localpeer) - 1); break;
Willy Tarreau5d01a632009-06-22 16:02:30 +02001325 case 'f' :
Maxime de Roucy0f503922016-05-13 23:52:55 +02001326 if (!list_append_word(&cfg_cfgfiles, *argv, &err_msg)) {
1327 Alert("Cannot load configuration file/directory %s : %s\n",
1328 *argv,
1329 err_msg);
Willy Tarreau5d01a632009-06-22 16:02:30 +02001330 exit(1);
1331 }
Willy Tarreau5d01a632009-06-22 16:02:30 +02001332 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001333 case 'p' : cfg_pidfile = *argv; break;
Willy Tarreau3bafcdc2011-09-10 19:20:23 +02001334 default: usage(progname);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001335 }
1336 }
1337 }
1338 else
Willy Tarreau3bafcdc2011-09-10 19:20:23 +02001339 usage(progname);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001340 argv++; argc--;
1341 }
1342
1343 global.mode = MODE_STARTING | /* during startup, we want most of the alerts */
William Lallemand095ba4c2017-06-01 17:38:50 +02001344 (arg_mode & (MODE_DAEMON | MODE_MWORKER | MODE_FOREGROUND | MODE_VERBOSE
Willy Tarreaubaaee002006-06-26 02:48:02 +02001345 | MODE_QUIET | MODE_CHECK | MODE_DEBUG));
1346
William Lallemandcb11fd22017-06-01 17:38:52 +02001347 /* Master workers wait mode */
1348 if ((global.mode & MODE_MWORKER) && (getenv("HAPROXY_MWORKER_WAIT_ONLY") != NULL)) {
1349
1350 unsetenv("HAPROXY_MWORKER_WAIT_ONLY");
1351 mworker_wait();
1352 }
1353
1354 if ((global.mode & MODE_MWORKER) && (getenv("HAPROXY_MWORKER_REEXEC") != NULL)) {
1355 atexit_flag = 1;
1356 atexit(reexec_on_failure);
1357 }
1358
Willy Tarreau576132e2011-09-10 19:26:56 +02001359 if (change_dir && chdir(change_dir) < 0) {
1360 Alert("Could not change to directory %s : %s\n", change_dir, strerror(errno));
1361 exit(1);
1362 }
1363
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001364 /* handle cfgfiles that are actualy directories */
1365 cfgfiles_expand_directories();
1366
1367 if (LIST_ISEMPTY(&cfg_cfgfiles))
1368 usage(progname);
1369
Willy Tarreaubaaee002006-06-26 02:48:02 +02001370 global.maxsock = 10; /* reserve 10 fds ; will be incremented by socket eaters */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001371
1372 init_default_instance();
1373
Willy Tarreau477ecd82010-01-03 21:12:30 +01001374 list_for_each_entry(wl, &cfg_cfgfiles, list) {
Willy Tarreauc4382422009-12-06 13:10:44 +01001375 int ret;
1376
Willy Tarreau477ecd82010-01-03 21:12:30 +01001377 ret = readcfgfile(wl->s);
Willy Tarreauc4382422009-12-06 13:10:44 +01001378 if (ret == -1) {
1379 Alert("Could not open configuration file %s : %s\n",
Willy Tarreau477ecd82010-01-03 21:12:30 +01001380 wl->s, strerror(errno));
Willy Tarreauc4382422009-12-06 13:10:44 +01001381 exit(1);
1382 }
Willy Tarreau25a67fa2009-12-15 21:46:25 +01001383 if (ret & (ERR_ABORT|ERR_FATAL))
Willy Tarreau477ecd82010-01-03 21:12:30 +01001384 Alert("Error(s) found in configuration file : %s\n", wl->s);
Willy Tarreau25a67fa2009-12-15 21:46:25 +01001385 err_code |= ret;
Willy Tarreau058e9072009-07-20 09:30:05 +02001386 if (err_code & ERR_ABORT)
Willy Tarreau5d01a632009-06-22 16:02:30 +02001387 exit(1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001388 }
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001389
Willy Tarreaub83dc3d2017-04-19 11:24:07 +02001390 /* do not try to resolve arguments nor to spot inconsistencies when
1391 * the configuration contains fatal errors caused by files not found
1392 * or failed memory allocations.
1393 */
1394 if (err_code & (ERR_ABORT|ERR_FATAL)) {
1395 Alert("Fatal errors found in configuration.\n");
1396 exit(1);
1397 }
1398
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001399 pattern_finalize_config();
1400
Willy Tarreaubb925012009-07-23 13:36:36 +02001401 err_code |= check_config_validity();
1402 if (err_code & (ERR_ABORT|ERR_FATAL)) {
1403 Alert("Fatal errors found in configuration.\n");
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001404 exit(1);
1405 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001406
Willy Tarreau70060452015-12-14 12:46:07 +01001407 /* recompute the amount of per-process memory depending on nbproc and
1408 * the shared SSL cache size (allowed to exist in all processes).
1409 */
1410 if (global.rlimit_memmax_all) {
1411#if defined (USE_OPENSSL) && !defined(USE_PRIVATE_CACHE)
1412 int64_t ssl_cache_bytes = global.tune.sslcachesize * 200LL;
1413
1414 global.rlimit_memmax =
1415 ((((int64_t)global.rlimit_memmax_all * 1048576LL) -
1416 ssl_cache_bytes) / global.nbproc +
1417 ssl_cache_bytes + 1048575LL) / 1048576LL;
1418#else
1419 global.rlimit_memmax = global.rlimit_memmax_all / global.nbproc;
1420#endif
1421 }
1422
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001423#ifdef CONFIG_HAP_NS
1424 err_code |= netns_init();
1425 if (err_code & (ERR_ABORT|ERR_FATAL)) {
1426 Alert("Failed to initialize namespace support.\n");
1427 exit(1);
1428 }
1429#endif
1430
Baptiste Assmann4215d7d2016-11-02 15:33:15 +01001431 /* Apply server states */
1432 apply_server_state();
1433
1434 for (px = proxy; px; px = px->next)
1435 srv_compute_all_admin_states(px);
1436
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01001437 /* Apply servers' configured address */
1438 err_code |= srv_init_addr();
1439 if (err_code & (ERR_ABORT|ERR_FATAL)) {
1440 Alert("Failed to initialize server(s) addr.\n");
1441 exit(1);
1442 }
1443
Willy Tarreaubaaee002006-06-26 02:48:02 +02001444 if (global.mode & MODE_CHECK) {
Willy Tarreau8b15ba12012-02-02 17:48:18 +01001445 struct peers *pr;
1446 struct proxy *px;
1447
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02001448 for (pr = cfg_peers; pr; pr = pr->next)
Willy Tarreau8b15ba12012-02-02 17:48:18 +01001449 if (pr->peers_fe)
1450 break;
1451
1452 for (px = proxy; px; px = px->next)
Willy Tarreau4348fad2012-09-20 16:48:07 +02001453 if (px->state == PR_STNEW && !LIST_ISEMPTY(&px->conf.listeners))
Willy Tarreau8b15ba12012-02-02 17:48:18 +01001454 break;
1455
1456 if (pr || px) {
1457 /* At least one peer or one listener has been found */
1458 qfprintf(stdout, "Configuration file is valid\n");
1459 exit(0);
1460 }
1461 qfprintf(stdout, "Configuration file has no error but will not start (no listener) => exit(2).\n");
1462 exit(2);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001463 }
1464
Willy Tarreaue9b26022011-08-01 20:57:55 +02001465 global_listener_queue_task = task_new();
1466 if (!global_listener_queue_task) {
1467 Alert("Out of memory when initializing global task\n");
1468 exit(1);
1469 }
1470 /* very simple initialization, users will queue the task if needed */
1471 global_listener_queue_task->context = NULL; /* not even a context! */
1472 global_listener_queue_task->process = manage_global_listener_queue;
Willy Tarreaue9b26022011-08-01 20:57:55 +02001473
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001474 /* now we know the buffer size, we can initialize the channels and buffers */
Willy Tarreau9b28e032012-10-12 23:49:43 +02001475 init_buffer();
Willy Tarreau8280d642009-09-23 23:37:52 +02001476
Willy Tarreaue6945732016-12-21 19:57:00 +01001477 list_for_each_entry(pcf, &post_check_list, list) {
1478 err_code |= pcf->fct();
1479 if (err_code & (ERR_ABORT|ERR_FATAL))
1480 exit(1);
1481 }
1482
Willy Tarreaubaaee002006-06-26 02:48:02 +02001483 if (cfg_maxconn > 0)
1484 global.maxconn = cfg_maxconn;
1485
1486 if (cfg_pidfile) {
Willy Tarreaua534fea2008-08-03 12:19:50 +02001487 free(global.pidfile);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001488 global.pidfile = strdup(cfg_pidfile);
1489 }
1490
Willy Tarreaud0256482015-01-15 21:45:22 +01001491 /* Now we want to compute the maxconn and possibly maxsslconn values.
1492 * It's a bit tricky. If memmax is not set, maxconn defaults to
1493 * DEFAULT_MAXCONN and maxsslconn defaults to DEFAULT_MAXSSLCONN.
1494 *
1495 * If memmax is set, then it depends on which values are set. If
1496 * maxsslconn is set, we use memmax to determine how many cleartext
1497 * connections may be added, and set maxconn to the sum of the two.
1498 * If maxconn is set and not maxsslconn, maxsslconn is computed from
1499 * the remaining amount of memory between memmax and the cleartext
1500 * connections. If neither are set, then it is considered that all
1501 * connections are SSL-capable, and maxconn is computed based on this,
1502 * then maxsslconn accordingly. We need to know if SSL is used on the
1503 * frontends, backends, or both, because when it's used on both sides,
1504 * we need twice the value for maxsslconn, but we only count the
1505 * handshake once since it is not performed on the two sides at the
1506 * same time (frontend-side is terminated before backend-side begins).
1507 * The SSL stack is supposed to have filled ssl_session_cost and
Willy Tarreau474b96a2015-01-28 19:03:21 +01001508 * ssl_handshake_cost during its initialization. In any case, if
1509 * SYSTEM_MAXCONN is set, we still enforce it as an upper limit for
1510 * maxconn in order to protect the system.
Willy Tarreaud0256482015-01-15 21:45:22 +01001511 */
1512 if (!global.rlimit_memmax) {
1513 if (global.maxconn == 0) {
1514 global.maxconn = DEFAULT_MAXCONN;
1515 if (global.mode & (MODE_VERBOSE|MODE_DEBUG))
1516 fprintf(stderr, "Note: setting global.maxconn to %d.\n", global.maxconn);
1517 }
1518 }
1519#ifdef USE_OPENSSL
1520 else if (!global.maxconn && !global.maxsslconn &&
1521 (global.ssl_used_frontend || global.ssl_used_backend)) {
1522 /* memmax is set, compute everything automatically. Here we want
1523 * to ensure that all SSL connections will be served. We take
1524 * care of the number of sides where SSL is used, and consider
1525 * the worst case : SSL used on both sides and doing a handshake
1526 * simultaneously. Note that we can't have more than maxconn
1527 * handshakes at a time by definition, so for the worst case of
1528 * two SSL conns per connection, we count a single handshake.
1529 */
1530 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
1531 int64_t mem = global.rlimit_memmax * 1048576ULL;
1532
1533 mem -= global.tune.sslcachesize * 200; // about 200 bytes per SSL cache entry
1534 mem -= global.maxzlibmem;
1535 mem = mem * MEM_USABLE_RATIO;
1536
1537 global.maxconn = mem /
Willy Tarreau87b09662015-04-03 00:22:06 +02001538 ((STREAM_MAX_COST + 2 * global.tune.bufsize) + // stream + 2 buffers per stream
Willy Tarreaud0256482015-01-15 21:45:22 +01001539 sides * global.ssl_session_max_cost + // SSL buffers, one per side
1540 global.ssl_handshake_max_cost); // 1 handshake per connection max
1541
1542 global.maxconn = round_2dig(global.maxconn);
Willy Tarreau474b96a2015-01-28 19:03:21 +01001543#ifdef SYSTEM_MAXCONN
1544 if (global.maxconn > DEFAULT_MAXCONN)
1545 global.maxconn = DEFAULT_MAXCONN;
1546#endif /* SYSTEM_MAXCONN */
Willy Tarreaud0256482015-01-15 21:45:22 +01001547 global.maxsslconn = sides * global.maxconn;
1548 if (global.mode & (MODE_VERBOSE|MODE_DEBUG))
1549 fprintf(stderr, "Note: setting global.maxconn to %d and global.maxsslconn to %d.\n",
1550 global.maxconn, global.maxsslconn);
1551 }
1552 else if (!global.maxsslconn &&
1553 (global.ssl_used_frontend || global.ssl_used_backend)) {
1554 /* memmax and maxconn are known, compute maxsslconn automatically.
1555 * maxsslconn being forced, we don't know how many of it will be
1556 * on each side if both sides are being used. The worst case is
1557 * when all connections use only one SSL instance because
1558 * handshakes may be on two sides at the same time.
1559 */
1560 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
1561 int64_t mem = global.rlimit_memmax * 1048576ULL;
1562 int64_t sslmem;
1563
1564 mem -= global.tune.sslcachesize * 200; // about 200 bytes per SSL cache entry
1565 mem -= global.maxzlibmem;
1566 mem = mem * MEM_USABLE_RATIO;
1567
Willy Tarreau87b09662015-04-03 00:22:06 +02001568 sslmem = mem - global.maxconn * (int64_t)(STREAM_MAX_COST + 2 * global.tune.bufsize);
Willy Tarreaud0256482015-01-15 21:45:22 +01001569 global.maxsslconn = sslmem / (global.ssl_session_max_cost + global.ssl_handshake_max_cost);
1570 global.maxsslconn = round_2dig(global.maxsslconn);
1571
1572 if (sslmem <= 0 || global.maxsslconn < sides) {
1573 Alert("Cannot compute the automatic maxsslconn because global.maxconn is already too "
1574 "high for the global.memmax value (%d MB). The absolute maximum possible value "
1575 "without SSL is %d, but %d was found and SSL is in use.\n",
1576 global.rlimit_memmax,
Willy Tarreau87b09662015-04-03 00:22:06 +02001577 (int)(mem / (STREAM_MAX_COST + 2 * global.tune.bufsize)),
Willy Tarreaud0256482015-01-15 21:45:22 +01001578 global.maxconn);
1579 exit(1);
1580 }
1581
1582 if (global.maxsslconn > sides * global.maxconn)
1583 global.maxsslconn = sides * global.maxconn;
1584
1585 if (global.mode & (MODE_VERBOSE|MODE_DEBUG))
1586 fprintf(stderr, "Note: setting global.maxsslconn to %d\n", global.maxsslconn);
1587 }
1588#endif
1589 else if (!global.maxconn) {
1590 /* memmax and maxsslconn are known/unused, compute maxconn automatically */
1591 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
1592 int64_t mem = global.rlimit_memmax * 1048576ULL;
1593 int64_t clearmem;
1594
1595 if (global.ssl_used_frontend || global.ssl_used_backend)
1596 mem -= global.tune.sslcachesize * 200; // about 200 bytes per SSL cache entry
1597
1598 mem -= global.maxzlibmem;
1599 mem = mem * MEM_USABLE_RATIO;
1600
1601 clearmem = mem;
1602 if (sides)
1603 clearmem -= (global.ssl_session_max_cost + global.ssl_handshake_max_cost) * (int64_t)global.maxsslconn;
1604
Willy Tarreau87b09662015-04-03 00:22:06 +02001605 global.maxconn = clearmem / (STREAM_MAX_COST + 2 * global.tune.bufsize);
Willy Tarreaud0256482015-01-15 21:45:22 +01001606 global.maxconn = round_2dig(global.maxconn);
Willy Tarreau474b96a2015-01-28 19:03:21 +01001607#ifdef SYSTEM_MAXCONN
1608 if (global.maxconn > DEFAULT_MAXCONN)
1609 global.maxconn = DEFAULT_MAXCONN;
1610#endif /* SYSTEM_MAXCONN */
Willy Tarreaud0256482015-01-15 21:45:22 +01001611
1612 if (clearmem <= 0 || !global.maxconn) {
1613 Alert("Cannot compute the automatic maxconn because global.maxsslconn is already too "
1614 "high for the global.memmax value (%d MB). The absolute maximum possible value "
1615 "is %d, but %d was found.\n",
1616 global.rlimit_memmax,
1617 (int)(mem / (global.ssl_session_max_cost + global.ssl_handshake_max_cost)),
1618 global.maxsslconn);
1619 exit(1);
1620 }
1621
1622 if (global.mode & (MODE_VERBOSE|MODE_DEBUG)) {
1623 if (sides && global.maxsslconn > sides * global.maxconn) {
1624 fprintf(stderr, "Note: global.maxsslconn is forced to %d which causes global.maxconn "
1625 "to be limited to %d. Better reduce global.maxsslconn to get more "
1626 "room for extra connections.\n", global.maxsslconn, global.maxconn);
1627 }
1628 fprintf(stderr, "Note: setting global.maxconn to %d\n", global.maxconn);
1629 }
1630 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001631
Willy Tarreau66aa61f2009-01-18 21:44:07 +01001632 if (!global.maxpipes) {
1633 /* maxpipes not specified. Count how many frontends and backends
1634 * may be using splicing, and bound that to maxconn.
1635 */
1636 struct proxy *cur;
1637 int nbfe = 0, nbbe = 0;
1638
1639 for (cur = proxy; cur; cur = cur->next) {
1640 if (cur->options2 & (PR_O2_SPLIC_ANY)) {
1641 if (cur->cap & PR_CAP_FE)
1642 nbfe += cur->maxconn;
1643 if (cur->cap & PR_CAP_BE)
Willy Tarreauafb48762009-01-25 10:42:05 +01001644 nbbe += cur->fullconn ? cur->fullconn : global.maxconn;
Willy Tarreau66aa61f2009-01-18 21:44:07 +01001645 }
1646 }
1647 global.maxpipes = MAX(nbfe, nbbe);
1648 if (global.maxpipes > global.maxconn)
1649 global.maxpipes = global.maxconn;
Willy Tarreau686ac822009-01-25 14:06:58 +01001650 global.maxpipes /= 4;
Willy Tarreau66aa61f2009-01-18 21:44:07 +01001651 }
1652
1653
Willy Tarreauabacc2c2011-09-07 14:26:33 +02001654 global.hardmaxconn = global.maxconn; /* keep this max value */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001655 global.maxsock += global.maxconn * 2; /* each connection needs two sockets */
Willy Tarreau3ec79b92009-01-18 20:39:42 +01001656 global.maxsock += global.maxpipes * 2; /* each pipe needs two FDs */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001657
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001658 if (global.stats_fe)
1659 global.maxsock += global.stats_fe->maxconn;
1660
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02001661 if (cfg_peers) {
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001662 /* peers also need to bypass global maxconn */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02001663 struct peers *p = cfg_peers;
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001664
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02001665 for (p = cfg_peers; p; p = p->next)
Willy Tarreau3c63fd82011-09-07 18:00:47 +02001666 if (p->peers_fe)
1667 global.maxsock += p->peers_fe->maxconn;
1668 }
1669
Willy Tarreau1db37712007-06-03 17:16:49 +02001670 if (global.tune.maxpollevents <= 0)
1671 global.tune.maxpollevents = MAX_POLL_EVENTS;
1672
Willy Tarreau6f4a82c2009-03-21 20:43:57 +01001673 if (global.tune.recv_enough == 0)
1674 global.tune.recv_enough = MIN_RECV_AT_ONCE_ENOUGH;
1675
Willy Tarreau27097842015-09-28 13:53:23 +02001676 if (global.tune.maxrewrite < 0)
1677 global.tune.maxrewrite = MAXREWRITE;
1678
Willy Tarreau27a674e2009-08-17 07:23:33 +02001679 if (global.tune.maxrewrite >= global.tune.bufsize / 2)
1680 global.tune.maxrewrite = global.tune.bufsize / 2;
1681
Willy Tarreaubaaee002006-06-26 02:48:02 +02001682 if (arg_mode & (MODE_DEBUG | MODE_FOREGROUND)) {
1683 /* command line debug mode inhibits configuration mode */
William Lallemand095ba4c2017-06-01 17:38:50 +02001684 global.mode &= ~(MODE_DAEMON | MODE_QUIET);
Willy Tarreau772f0dd2012-10-26 16:04:28 +02001685 global.mode |= (arg_mode & (MODE_DEBUG | MODE_FOREGROUND));
1686 }
1687
William Lallemand095ba4c2017-06-01 17:38:50 +02001688 if (arg_mode & MODE_DAEMON) {
Willy Tarreau772f0dd2012-10-26 16:04:28 +02001689 /* command line daemon mode inhibits foreground and debug modes mode */
1690 global.mode &= ~(MODE_DEBUG | MODE_FOREGROUND);
William Lallemand095ba4c2017-06-01 17:38:50 +02001691 global.mode |= arg_mode & MODE_DAEMON;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001692 }
Willy Tarreau772f0dd2012-10-26 16:04:28 +02001693
1694 global.mode |= (arg_mode & (MODE_QUIET | MODE_VERBOSE));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001695
William Lallemand095ba4c2017-06-01 17:38:50 +02001696 if ((global.mode & MODE_DEBUG) && (global.mode & (MODE_DAEMON | MODE_QUIET))) {
1697 Warning("<debug> mode incompatible with <quiet> and <daemon>. Keeping <debug> only.\n");
1698 global.mode &= ~(MODE_DAEMON | MODE_QUIET);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001699 }
1700
William Lallemand095ba4c2017-06-01 17:38:50 +02001701 if ((global.nbproc > 1) && !(global.mode & (MODE_DAEMON | MODE_MWORKER))) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001702 if (!(global.mode & (MODE_FOREGROUND | MODE_DEBUG)))
1703 Warning("<nbproc> is only meaningful in daemon mode. Setting limit to 1 process.\n");
1704 global.nbproc = 1;
1705 }
1706
1707 if (global.nbproc < 1)
1708 global.nbproc = 1;
1709
Christopher Faulet3ef26392017-08-29 16:46:57 +02001710 /* Realloc trash buffers because global.tune.bufsize may have changed */
1711 if (!init_trash_buffers()) {
1712 Alert("failed to initialize trash buffers.\n");
1713 exit(1);
1714 }
1715
Christopher Faulet084aa962017-08-29 16:54:41 +02001716 if (!init_log_buffers()) {
1717 Alert("failed to initialize log buffers.\n");
1718 exit(1);
1719 }
1720
Willy Tarreauef1d1f82007-04-16 00:25:25 +02001721 /*
1722 * Note: we could register external pollers here.
1723 * Built-in pollers have been registered before main().
1724 */
Willy Tarreau4f60f162007-04-08 16:39:58 +02001725
Willy Tarreau43b78992009-01-25 15:42:27 +01001726 if (!(global.tune.options & GTUNE_USE_KQUEUE))
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001727 disable_poller("kqueue");
1728
Willy Tarreau43b78992009-01-25 15:42:27 +01001729 if (!(global.tune.options & GTUNE_USE_EPOLL))
Willy Tarreau4f60f162007-04-08 16:39:58 +02001730 disable_poller("epoll");
1731
Willy Tarreau43b78992009-01-25 15:42:27 +01001732 if (!(global.tune.options & GTUNE_USE_POLL))
Willy Tarreau4f60f162007-04-08 16:39:58 +02001733 disable_poller("poll");
1734
Willy Tarreau43b78992009-01-25 15:42:27 +01001735 if (!(global.tune.options & GTUNE_USE_SELECT))
Willy Tarreau4f60f162007-04-08 16:39:58 +02001736 disable_poller("select");
1737
1738 /* Note: we could disable any poller by name here */
1739
Christopher Fauletb3f4e142016-03-07 12:46:38 +01001740 if (global.mode & (MODE_VERBOSE|MODE_DEBUG)) {
Willy Tarreau2ff76222007-04-09 19:29:56 +02001741 list_pollers(stderr);
Christopher Fauletb3f4e142016-03-07 12:46:38 +01001742 fprintf(stderr, "\n");
1743 list_filters(stderr);
1744 }
Willy Tarreau2ff76222007-04-09 19:29:56 +02001745
Willy Tarreau4f60f162007-04-08 16:39:58 +02001746 if (!init_pollers()) {
Willy Tarreau3fa87b12013-03-31 14:41:15 +02001747 Alert("No polling mechanism available.\n"
1748 " It is likely that haproxy was built with TARGET=generic and that FD_SETSIZE\n"
1749 " is too low on this platform to support maxconn and the number of listeners\n"
1750 " and servers. You should rebuild haproxy specifying your system using TARGET=\n"
1751 " in order to support other polling systems (poll, epoll, kqueue) or reduce the\n"
Prach Pongpanichb837e682013-05-14 20:56:28 +02001752 " global maxconn setting to accommodate the system's limitation. For reference,\n"
Willy Tarreau3fa87b12013-03-31 14:41:15 +02001753 " FD_SETSIZE=%d on this system, global.maxconn=%d resulting in a maximum of\n"
1754 " %d file descriptors. You should thus reduce global.maxconn by %d. Also,\n"
1755 " check build settings using 'haproxy -vv'.\n\n",
1756 FD_SETSIZE, global.maxconn, global.maxsock, (global.maxsock + 1 - FD_SETSIZE) / 2);
Willy Tarreau4f60f162007-04-08 16:39:58 +02001757 exit(1);
1758 }
Willy Tarreau2ff76222007-04-09 19:29:56 +02001759 if (global.mode & (MODE_VERBOSE|MODE_DEBUG)) {
1760 printf("Using %s() as the polling mechanism.\n", cur_poller.name);
Willy Tarreau4f60f162007-04-08 16:39:58 +02001761 }
1762
Krzysztof Piotr Oledzki48cb2ae2009-10-02 22:51:14 +02001763 if (!global.node)
1764 global.node = strdup(hostname);
1765
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01001766 if (!hlua_post_init())
1767 exit(1);
Thomas Holmes6abded42015-05-12 16:23:58 +01001768
Maxime de Roucy0f503922016-05-13 23:52:55 +02001769 free(err_msg);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001770}
1771
Simon Horman6fb82592011-07-15 13:14:11 +09001772static void deinit_acl_cond(struct acl_cond *cond)
Simon Hormanac821422011-07-15 13:14:09 +09001773{
Simon Hormanac821422011-07-15 13:14:09 +09001774 struct acl_term_suite *suite, *suiteb;
1775 struct acl_term *term, *termb;
1776
Simon Horman6fb82592011-07-15 13:14:11 +09001777 if (!cond)
1778 return;
1779
1780 list_for_each_entry_safe(suite, suiteb, &cond->suites, list) {
1781 list_for_each_entry_safe(term, termb, &suite->terms, list) {
1782 LIST_DEL(&term->list);
1783 free(term);
Simon Hormanac821422011-07-15 13:14:09 +09001784 }
Simon Horman6fb82592011-07-15 13:14:11 +09001785 LIST_DEL(&suite->list);
1786 free(suite);
1787 }
1788
1789 free(cond);
1790}
1791
1792static void deinit_tcp_rules(struct list *rules)
1793{
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02001794 struct act_rule *trule, *truleb;
Simon Horman6fb82592011-07-15 13:14:11 +09001795
1796 list_for_each_entry_safe(trule, truleb, rules, list) {
Simon Hormanac821422011-07-15 13:14:09 +09001797 LIST_DEL(&trule->list);
Simon Horman6fb82592011-07-15 13:14:11 +09001798 deinit_acl_cond(trule->cond);
Simon Hormanac821422011-07-15 13:14:09 +09001799 free(trule);
1800 }
1801}
1802
Simon Horman6fb82592011-07-15 13:14:11 +09001803static void deinit_stick_rules(struct list *rules)
1804{
1805 struct sticking_rule *rule, *ruleb;
1806
1807 list_for_each_entry_safe(rule, ruleb, rules, list) {
1808 LIST_DEL(&rule->list);
1809 deinit_acl_cond(rule->cond);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001810 release_sample_expr(rule->expr);
Simon Horman6fb82592011-07-15 13:14:11 +09001811 free(rule);
1812 }
1813}
1814
Cyril Bonté203ec5a2017-03-23 22:44:13 +01001815void deinit(void)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001816{
Willy Tarreau4d2d0982007-05-14 00:39:29 +02001817 struct proxy *p = proxy, *p0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001818 struct cap_hdr *h,*h_next;
1819 struct server *s,*s_next;
1820 struct listener *l,*l_next;
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001821 struct acl_cond *cond, *condb;
1822 struct hdr_exp *exp, *expb;
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02001823 struct acl *acl, *aclb;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001824 struct switching_rule *rule, *ruleb;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001825 struct server_rule *srule, *sruleb;
Willy Tarreaub463dfb2008-06-07 23:08:56 +02001826 struct redirect_rule *rdr, *rdrb;
Willy Tarreaudeb9ed82010-01-03 21:03:22 +01001827 struct wordlist *wl, *wlb;
Willy Tarreauf4f04122010-01-28 18:10:50 +01001828 struct cond_wordlist *cwl, *cwlb;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001829 struct uri_auth *uap, *ua = NULL;
William Lallemand0f99e342011-10-12 17:50:54 +02001830 struct logsrv *log, *logb;
William Lallemand723b73a2012-02-08 16:37:49 +01001831 struct logformat_node *lf, *lfb;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001832 struct bind_conf *bind_conf, *bind_back;
Willy Tarreaucdb737e2016-12-21 18:43:10 +01001833 struct build_opts_str *bol, *bolb;
Willy Tarreau05554e62016-12-21 20:46:26 +01001834 struct post_deinit_fct *pdf;
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001835 int i;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001836
Willy Tarreau24f4efa2010-08-27 17:56:48 +02001837 deinit_signals();
Willy Tarreaubaaee002006-06-26 02:48:02 +02001838 while (p) {
Willy Tarreau8113a5d2012-10-04 08:01:43 +02001839 free(p->conf.file);
Willy Tarreaua534fea2008-08-03 12:19:50 +02001840 free(p->id);
1841 free(p->check_req);
1842 free(p->cookie_name);
1843 free(p->cookie_domain);
1844 free(p->url_param_name);
1845 free(p->capture_name);
1846 free(p->monitor_uri);
Simon Hormana31c7f72011-07-15 13:14:08 +09001847 free(p->rdp_cookie_name);
Willy Tarreau62a61232013-04-12 18:13:46 +02001848 if (p->conf.logformat_string != default_http_log_format &&
1849 p->conf.logformat_string != default_tcp_log_format &&
1850 p->conf.logformat_string != clf_http_log_format)
1851 free(p->conf.logformat_string);
Willy Tarreau196729e2012-05-31 19:30:26 +02001852
Willy Tarreau62a61232013-04-12 18:13:46 +02001853 free(p->conf.lfs_file);
1854 free(p->conf.uniqueid_format_string);
1855 free(p->conf.uif_file);
Godbachaf1a75d2013-10-02 17:10:11 +08001856 free(p->lbprm.map.srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001857
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001858 if (p->conf.logformat_sd_string != default_rfc5424_sd_log_format)
1859 free(p->conf.logformat_sd_string);
1860 free(p->conf.lfsd_file);
1861
Willy Tarreaua534fea2008-08-03 12:19:50 +02001862 for (i = 0; i < HTTP_ERR_SIZE; i++)
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +02001863 chunk_destroy(&p->errmsg[i]);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001864
Willy Tarreauf4f04122010-01-28 18:10:50 +01001865 list_for_each_entry_safe(cwl, cwlb, &p->req_add, list) {
1866 LIST_DEL(&cwl->list);
1867 free(cwl->s);
1868 free(cwl);
Willy Tarreaudeb9ed82010-01-03 21:03:22 +01001869 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001870
Willy Tarreauf4f04122010-01-28 18:10:50 +01001871 list_for_each_entry_safe(cwl, cwlb, &p->rsp_add, list) {
1872 LIST_DEL(&cwl->list);
1873 free(cwl->s);
1874 free(cwl);
Willy Tarreaudeb9ed82010-01-03 21:03:22 +01001875 }
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001876
Willy Tarreaub80c2302007-11-30 20:51:32 +01001877 list_for_each_entry_safe(cond, condb, &p->mon_fail_cond, list) {
1878 LIST_DEL(&cond->list);
1879 prune_acl_cond(cond);
1880 free(cond);
1881 }
1882
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001883 for (exp = p->req_exp; exp != NULL; ) {
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001884 if (exp->preg) {
Thierry FOURNIER09af0d62014-06-18 11:35:54 +02001885 regex_free(exp->preg);
1886 free(exp->preg);
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001887 }
1888
Willy Tarreau98d04852015-05-26 12:18:29 +02001889 free((char *)exp->replace);
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001890 expb = exp;
1891 exp = exp->next;
1892 free(expb);
1893 }
1894
1895 for (exp = p->rsp_exp; exp != NULL; ) {
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001896 if (exp->preg) {
Thierry FOURNIER09af0d62014-06-18 11:35:54 +02001897 regex_free(exp->preg);
1898 free(exp->preg);
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001899 }
1900
Willy Tarreau98d04852015-05-26 12:18:29 +02001901 free((char *)exp->replace);
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001902 expb = exp;
1903 exp = exp->next;
1904 free(expb);
1905 }
1906
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001907 /* build a list of unique uri_auths */
1908 if (!ua)
1909 ua = p->uri_auth;
1910 else {
1911 /* check if p->uri_auth is unique */
1912 for (uap = ua; uap; uap=uap->next)
1913 if (uap == p->uri_auth)
1914 break;
1915
Willy Tarreauaccc4e12008-06-24 11:14:45 +02001916 if (!uap && p->uri_auth) {
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001917 /* add it, if it is */
1918 p->uri_auth->next = ua;
1919 ua = p->uri_auth;
1920 }
1921 }
Willy Tarreau0fc45a72007-06-17 00:36:03 +02001922
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02001923 list_for_each_entry_safe(acl, aclb, &p->acl, list) {
1924 LIST_DEL(&acl->list);
1925 prune_acl(acl);
1926 free(acl);
1927 }
1928
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001929 list_for_each_entry_safe(srule, sruleb, &p->server_rules, list) {
1930 LIST_DEL(&srule->list);
1931 prune_acl_cond(srule->cond);
1932 free(srule->cond);
1933 free(srule);
1934 }
1935
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001936 list_for_each_entry_safe(rule, ruleb, &p->switching_rules, list) {
1937 LIST_DEL(&rule->list);
Willy Tarreauf51658d2014-04-23 01:21:56 +02001938 if (rule->cond) {
1939 prune_acl_cond(rule->cond);
1940 free(rule->cond);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01001941 free(rule->file);
Willy Tarreauf51658d2014-04-23 01:21:56 +02001942 }
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001943 free(rule);
1944 }
1945
Willy Tarreaub463dfb2008-06-07 23:08:56 +02001946 list_for_each_entry_safe(rdr, rdrb, &p->redirect_rules, list) {
1947 LIST_DEL(&rdr->list);
Willy Tarreauf285f542010-01-03 20:03:03 +01001948 if (rdr->cond) {
1949 prune_acl_cond(rdr->cond);
1950 free(rdr->cond);
1951 }
Willy Tarreaub463dfb2008-06-07 23:08:56 +02001952 free(rdr->rdr_str);
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +01001953 list_for_each_entry_safe(lf, lfb, &rdr->rdr_fmt, list) {
1954 LIST_DEL(&lf->list);
1955 free(lf);
1956 }
Willy Tarreaub463dfb2008-06-07 23:08:56 +02001957 free(rdr);
1958 }
1959
William Lallemand0f99e342011-10-12 17:50:54 +02001960 list_for_each_entry_safe(log, logb, &p->logsrvs, list) {
1961 LIST_DEL(&log->list);
1962 free(log);
1963 }
1964
William Lallemand723b73a2012-02-08 16:37:49 +01001965 list_for_each_entry_safe(lf, lfb, &p->logformat, list) {
1966 LIST_DEL(&lf->list);
1967 free(lf);
1968 }
1969
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001970 list_for_each_entry_safe(lf, lfb, &p->logformat_sd, list) {
1971 LIST_DEL(&lf->list);
1972 free(lf);
1973 }
1974
Simon Hormanac821422011-07-15 13:14:09 +09001975 deinit_tcp_rules(&p->tcp_req.inspect_rules);
1976 deinit_tcp_rules(&p->tcp_req.l4_rules);
1977
Simon Horman6fb82592011-07-15 13:14:11 +09001978 deinit_stick_rules(&p->storersp_rules);
1979 deinit_stick_rules(&p->sticking_rules);
1980
Willy Tarreaubaaee002006-06-26 02:48:02 +02001981 h = p->req_cap;
1982 while (h) {
1983 h_next = h->next;
Willy Tarreaua534fea2008-08-03 12:19:50 +02001984 free(h->name);
Willy Tarreaucf7f3202007-05-13 22:46:04 +02001985 pool_destroy2(h->pool);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001986 free(h);
1987 h = h_next;
1988 }/* end while(h) */
1989
1990 h = p->rsp_cap;
1991 while (h) {
1992 h_next = h->next;
Willy Tarreaua534fea2008-08-03 12:19:50 +02001993 free(h->name);
Willy Tarreaucf7f3202007-05-13 22:46:04 +02001994 pool_destroy2(h->pool);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001995 free(h);
1996 h = h_next;
1997 }/* end while(h) */
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02001998
Willy Tarreaubaaee002006-06-26 02:48:02 +02001999 s = p->srv;
2000 while (s) {
2001 s_next = s->next;
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002002
Willy Tarreau5b3a2022012-09-28 15:01:02 +02002003 if (s->check.task) {
2004 task_delete(s->check.task);
2005 task_free(s->check.task);
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002006 }
Simon Hormand60d6912013-11-25 10:46:36 +09002007 if (s->agent.task) {
2008 task_delete(s->agent.task);
2009 task_free(s->agent.task);
2010 }
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002011
Willy Tarreau2e993902011-10-31 11:53:20 +01002012 if (s->warmup) {
2013 task_delete(s->warmup);
2014 task_free(s->warmup);
2015 }
2016
Willy Tarreaua534fea2008-08-03 12:19:50 +02002017 free(s->id);
2018 free(s->cookie);
Willy Tarreau1ae1b7b2012-09-28 15:28:30 +02002019 free(s->check.bi);
2020 free(s->check.bo);
Simon Hormand60d6912013-11-25 10:46:36 +09002021 free(s->agent.bi);
2022 free(s->agent.bo);
James Brown55f9ff12015-10-21 18:19:05 -07002023 free(s->agent.send_string);
Christopher Faulet67957bd2017-09-27 11:00:59 +02002024 free(s->hostname_dn);
Sárközi, László34c01792014-09-05 10:08:23 +02002025 free((char*)s->conf.file);
Willy Tarreau17d45382016-12-22 21:16:08 +01002026
2027 if (s->use_ssl || s->check.use_ssl) {
2028 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->destroy_srv)
2029 xprt_get(XPRT_SSL)->destroy_srv(s);
2030 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002031 free(s);
2032 s = s_next;
2033 }/* end while(s) */
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002034
Willy Tarreau4348fad2012-09-20 16:48:07 +02002035 list_for_each_entry_safe(l, l_next, &p->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02002036 /*
2037 * Zombie proxy, the listener just pretend to be up
2038 * because they still hold an opened fd.
2039 * Close it and give the listener its real state.
2040 */
2041 if (p->state == PR_STSTOPPED && l->state >= LI_ZOMBIE) {
2042 close(l->fd);
2043 l->state = LI_INIT;
2044 }
Willy Tarreauf6e2cc72010-09-03 10:38:17 +02002045 unbind_listener(l);
2046 delete_listener(l);
Willy Tarreau4348fad2012-09-20 16:48:07 +02002047 LIST_DEL(&l->by_fe);
2048 LIST_DEL(&l->by_bind);
Krzysztof Piotr Oledzkiaff01ea2010-02-05 20:31:44 +01002049 free(l->name);
2050 free(l->counters);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002051 free(l);
Willy Tarreau4348fad2012-09-20 16:48:07 +02002052 }
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002053
Willy Tarreau4348fad2012-09-20 16:48:07 +02002054 /* Release unused SSL configs. */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002055 list_for_each_entry_safe(bind_conf, bind_back, &p->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01002056 if (bind_conf->xprt->destroy_bind_conf)
2057 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002058 free(bind_conf->file);
2059 free(bind_conf->arg);
2060 LIST_DEL(&bind_conf->by_fe);
2061 free(bind_conf);
2062 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02002063
Christopher Fauletd7c91962015-04-30 11:48:27 +02002064 flt_deinit(p);
2065
Krzysztof Piotr Oledzkiaff01ea2010-02-05 20:31:44 +01002066 free(p->desc);
2067 free(p->fwdfor_hdr_name);
2068
Willy Tarreauff011f22011-01-06 17:51:27 +01002069 free_http_req_rules(&p->http_req_rules);
Sasha Pachev218f0642014-06-16 12:05:59 -06002070 free_http_res_rules(&p->http_res_rules);
Willy Tarreau918ff602011-07-25 16:33:49 +02002071 free(p->task);
Krzysztof Piotr Oledzki59bb2182010-01-29 17:58:21 +01002072
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002073 pool_destroy2(p->req_cap_pool);
2074 pool_destroy2(p->rsp_cap_pool);
Simon Hormanb08584a2011-07-15 13:14:10 +09002075 pool_destroy2(p->table.pool);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01002076
Willy Tarreau4d2d0982007-05-14 00:39:29 +02002077 p0 = p;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002078 p = p->next;
Willy Tarreau4d2d0982007-05-14 00:39:29 +02002079 free(p0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002080 }/* end while(p) */
Willy Tarreaudd815982007-10-16 12:25:14 +02002081
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002082 while (ua) {
2083 uap = ua;
2084 ua = ua->next;
2085
Willy Tarreaua534fea2008-08-03 12:19:50 +02002086 free(uap->uri_prefix);
2087 free(uap->auth_realm);
Krzysztof Piotr Oledzki48cb2ae2009-10-02 22:51:14 +02002088 free(uap->node);
2089 free(uap->desc);
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002090
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002091 userlist_free(uap->userlist);
Willy Tarreauff011f22011-01-06 17:51:27 +01002092 free_http_req_rules(&uap->http_req_rules);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002093
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002094 free(uap);
2095 }
2096
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01002097 userlist_free(userlist);
2098
David Carlier834cb2e2015-09-25 12:02:25 +01002099 cfg_unregister_sections();
2100
Christopher Faulet0132d062017-07-26 15:33:35 +02002101 deinit_log_buffers();
Christopher Faulet748919a2017-07-26 14:59:46 +02002102 deinit_trash_buffers();
David Carlier834cb2e2015-09-25 12:02:25 +01002103
Willy Tarreaudd815982007-10-16 12:25:14 +02002104 protocol_unbind_all();
2105
Willy Tarreau05554e62016-12-21 20:46:26 +01002106 list_for_each_entry(pdf, &post_deinit_list, list)
2107 pdf->fct();
2108
Joe Williamsdf5b38f2010-12-29 17:05:48 +01002109 free(global.log_send_hostname); global.log_send_hostname = NULL;
Dragan Dosen43885c72015-10-01 13:18:13 +02002110 chunk_destroy(&global.log_tag);
Willy Tarreaua534fea2008-08-03 12:19:50 +02002111 free(global.chroot); global.chroot = NULL;
2112 free(global.pidfile); global.pidfile = NULL;
Krzysztof Piotr Oledzki48cb2ae2009-10-02 22:51:14 +02002113 free(global.node); global.node = NULL;
2114 free(global.desc); global.desc = NULL;
Willy Tarreaua534fea2008-08-03 12:19:50 +02002115 free(oldpids); oldpids = NULL;
Willy Tarreaue9b26022011-08-01 20:57:55 +02002116 free(global_listener_queue_task); global_listener_queue_task = NULL;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002117
William Lallemand0f99e342011-10-12 17:50:54 +02002118 list_for_each_entry_safe(log, logb, &global.logsrvs, list) {
2119 LIST_DEL(&log->list);
2120 free(log);
2121 }
Willy Tarreau477ecd82010-01-03 21:12:30 +01002122 list_for_each_entry_safe(wl, wlb, &cfg_cfgfiles, list) {
Maxime de Roucy0f503922016-05-13 23:52:55 +02002123 free(wl->s);
Willy Tarreau477ecd82010-01-03 21:12:30 +01002124 LIST_DEL(&wl->list);
2125 free(wl);
2126 }
2127
Willy Tarreaucdb737e2016-12-21 18:43:10 +01002128 list_for_each_entry_safe(bol, bolb, &build_opts_list, list) {
2129 if (bol->must_free)
2130 free((void *)bol->str);
2131 LIST_DEL(&bol->list);
2132 free(bol);
2133 }
2134
Christopher Fauletff2613e2016-11-09 11:36:17 +01002135 vars_prune(&global.vars, NULL, NULL);
2136
Christopher Fauletad405f12017-08-29 15:30:11 +02002137 deinit_buffer();
2138
Willy Tarreau87b09662015-04-03 00:22:06 +02002139 pool_destroy2(pool2_stream);
Willy Tarreaufeb76402015-04-03 14:10:06 +02002140 pool_destroy2(pool2_session);
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002141 pool_destroy2(pool2_connection);
Willy Tarreaub686afd2017-02-08 11:06:11 +01002142 pool_destroy2(pool2_trash);
Willy Tarreau332f8bf2007-05-13 21:36:56 +02002143 pool_destroy2(pool2_requri);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +02002144 pool_destroy2(pool2_task);
Willy Tarreau086b3b42007-05-13 21:45:51 +02002145 pool_destroy2(pool2_capture);
Willy Tarreaue4d7e552007-05-13 20:19:55 +02002146 pool_destroy2(pool2_pendconn);
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002147 pool_destroy2(pool2_sig_handlers);
Willy Tarreau34eb6712011-10-24 18:15:04 +02002148 pool_destroy2(pool2_hdr_idx);
Willy Tarreau63986c72015-04-03 22:55:33 +02002149 pool_destroy2(pool2_http_txn);
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002150 deinit_pollers();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002151} /* end deinit() */
2152
Willy Tarreaubaaee002006-06-26 02:48:02 +02002153
Willy Tarreau918ff602011-07-25 16:33:49 +02002154/* Runs the polling loop */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +01002155static void run_poll_loop()
Willy Tarreau4f60f162007-04-08 16:39:58 +02002156{
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002157 int next;
Willy Tarreau4f60f162007-04-08 16:39:58 +02002158
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002159 tv_update_date(0,1);
Willy Tarreau4f60f162007-04-08 16:39:58 +02002160 while (1) {
Thierry FOURNIER9cf7c4b2014-12-15 13:26:01 +01002161 /* Process a few tasks */
2162 process_runnable_tasks();
2163
Willy Tarreau29857942009-05-10 09:01:21 +02002164 /* check if we caught some signals and process them */
2165 signal_process_queue();
2166
Willy Tarreau58b458d2008-06-29 22:40:23 +02002167 /* Check if we can expire some tasks */
Thierry FOURNIER9cf7c4b2014-12-15 13:26:01 +01002168 next = wake_expired_tasks();
Willy Tarreau4f60f162007-04-08 16:39:58 +02002169
Willy Tarreauaf7ad002010-08-31 15:39:26 +02002170 /* stop when there's nothing left to do */
2171 if (jobs == 0)
Willy Tarreau4f60f162007-04-08 16:39:58 +02002172 break;
2173
Willy Tarreau10146c92015-04-13 20:44:19 +02002174 /* expire immediately if events are pending */
Christopher Faulet34c5cc92016-12-06 09:15:30 +01002175 if (fd_cache_num || tasks_run_queue || signal_queue_len || applets_active_queue)
Willy Tarreau10146c92015-04-13 20:44:19 +02002176 next = now_ms;
2177
Willy Tarreau58b458d2008-06-29 22:40:23 +02002178 /* The poller will ensure it returns around <next> */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002179 cur_poller.poll(&cur_poller, next);
Willy Tarreau033cd9d2014-01-25 19:24:15 +01002180 fd_process_cached_events();
Willy Tarreau3c595ac2015-04-19 09:59:31 +02002181 applet_run_active();
Emeric Brun64cc49c2017-10-03 14:46:45 +02002182
2183 /* Commit server status changes */
2184 servers_update_status();
Willy Tarreau4f60f162007-04-08 16:39:58 +02002185 }
2186}
2187
Willy Tarreaue9b26022011-08-01 20:57:55 +02002188/* This is the global management task for listeners. It enables listeners waiting
2189 * for global resources when there are enough free resource, or at least once in
2190 * a while. It is designed to be called as a task.
2191 */
2192static struct task *manage_global_listener_queue(struct task *t)
2193{
2194 int next = TICK_ETERNITY;
Willy Tarreaue9b26022011-08-01 20:57:55 +02002195 /* queue is empty, nothing to do */
2196 if (LIST_ISEMPTY(&global_listener_queue))
2197 goto out;
2198
2199 /* If there are still too many concurrent connections, let's wait for
2200 * some of them to go away. We don't need to re-arm the timer because
2201 * each of them will scan the queue anyway.
2202 */
2203 if (unlikely(actconn >= global.maxconn))
2204 goto out;
2205
2206 /* We should periodically try to enable listeners waiting for a global
2207 * resource here, because it is possible, though very unlikely, that
2208 * they have been blocked by a temporary lack of global resource such
2209 * as a file descriptor or memory and that the temporary condition has
2210 * disappeared.
2211 */
Willy Tarreauabacc2c2011-09-07 14:26:33 +02002212 dequeue_all_listeners(&global_listener_queue);
Willy Tarreaue9b26022011-08-01 20:57:55 +02002213
2214 out:
2215 t->expire = next;
2216 task_queue(t);
2217 return t;
2218}
Willy Tarreau4f60f162007-04-08 16:39:58 +02002219
William Lallemande20b6a62017-06-01 17:38:55 +02002220void mworker_pipe_handler(int fd)
2221{
2222 char c;
2223
2224 while (read(fd, &c, 1) == -1) {
2225 if (errno == EINTR)
2226 continue;
2227 if (errno == EAGAIN) {
2228 fd_cant_recv(fd);
2229 return;
2230 }
2231 break;
2232 }
2233
2234 deinit();
2235 exit(EXIT_FAILURE);
2236 return;
2237}
2238
2239void mworker_pipe_register(int pipefd[2])
2240{
2241 close(mworker_pipe[1]); /* close the write end of the master pipe in the children */
2242
2243 fcntl(mworker_pipe[0], F_SETFL, O_NONBLOCK);
2244 fdtab[mworker_pipe[0]].owner = mworker_pipe;
2245 fdtab[mworker_pipe[0]].iocb = mworker_pipe_handler;
2246 fd_insert(mworker_pipe[0]);
2247 fd_want_recv(mworker_pipe[0]);
2248 }
2249
2250
Willy Tarreaubaaee002006-06-26 02:48:02 +02002251int main(int argc, char **argv)
2252{
2253 int err, retry;
2254 struct rlimit limit;
Emeric Bruncf20bf12010-10-22 16:06:11 +02002255 char errmsg[100];
Willy Tarreau269ab312012-09-05 08:02:48 +02002256 int pidfd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002257
Emeric Bruncf20bf12010-10-22 16:06:11 +02002258 init(argc, argv);
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002259 signal_register_fct(SIGQUIT, dump, SIGQUIT);
2260 signal_register_fct(SIGUSR1, sig_soft_stop, SIGUSR1);
2261 signal_register_fct(SIGHUP, sig_dump_state, SIGHUP);
William Lallemand73b85e72017-06-01 17:38:51 +02002262 signal_register_fct(SIGUSR2, NULL, 0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002263
Willy Tarreaue437c442010-03-17 18:02:46 +01002264 /* Always catch SIGPIPE even on platforms which define MSG_NOSIGNAL.
2265 * Some recent FreeBSD setups report broken pipes, and MSG_NOSIGNAL
2266 * was defined there, so let's stay on the safe side.
Willy Tarreaubaaee002006-06-26 02:48:02 +02002267 */
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002268 signal_register_fct(SIGPIPE, NULL, 0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002269
Willy Tarreaudc23a922011-02-16 11:10:36 +01002270 /* ulimits */
2271 if (!global.rlimit_nofile)
2272 global.rlimit_nofile = global.maxsock;
2273
2274 if (global.rlimit_nofile) {
2275 limit.rlim_cur = limit.rlim_max = global.rlimit_nofile;
2276 if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
Willy Tarreauef635472016-06-21 11:48:18 +02002277 /* try to set it to the max possible at least */
2278 getrlimit(RLIMIT_NOFILE, &limit);
Willy Tarreau164dd0b2016-06-21 11:51:59 +02002279 limit.rlim_cur = limit.rlim_max;
2280 if (setrlimit(RLIMIT_NOFILE, &limit) != -1)
2281 getrlimit(RLIMIT_NOFILE, &limit);
2282
Willy Tarreauef635472016-06-21 11:48:18 +02002283 Warning("[%s.main()] Cannot raise FD limit to %d, limit is %d.\n", argv[0], global.rlimit_nofile, (int)limit.rlim_cur);
2284 global.rlimit_nofile = limit.rlim_cur;
Willy Tarreaudc23a922011-02-16 11:10:36 +01002285 }
2286 }
2287
2288 if (global.rlimit_memmax) {
2289 limit.rlim_cur = limit.rlim_max =
Willy Tarreau70060452015-12-14 12:46:07 +01002290 global.rlimit_memmax * 1048576ULL;
Willy Tarreaudc23a922011-02-16 11:10:36 +01002291#ifdef RLIMIT_AS
2292 if (setrlimit(RLIMIT_AS, &limit) == -1) {
2293 Warning("[%s.main()] Cannot fix MEM limit to %d megs.\n",
2294 argv[0], global.rlimit_memmax);
2295 }
2296#else
2297 if (setrlimit(RLIMIT_DATA, &limit) == -1) {
2298 Warning("[%s.main()] Cannot fix MEM limit to %d megs.\n",
2299 argv[0], global.rlimit_memmax);
2300 }
2301#endif
2302 }
2303
Olivier Houchardf73629d2017-04-05 22:33:04 +02002304 if (old_unixsocket) {
William Lallemand85b0bd92017-06-01 17:38:53 +02002305 if (strcmp("/dev/null", old_unixsocket) != 0) {
2306 if (get_old_sockets(old_unixsocket) != 0) {
2307 Alert("Failed to get the sockets from the old process!\n");
2308 if (!(global.mode & MODE_MWORKER))
2309 exit(1);
2310 }
Olivier Houchardf73629d2017-04-05 22:33:04 +02002311 }
2312 }
William Lallemand85b0bd92017-06-01 17:38:53 +02002313 get_cur_unixsocket();
2314
Willy Tarreaubaaee002006-06-26 02:48:02 +02002315 /* We will loop at most 100 times with 10 ms delay each time.
2316 * That's at most 1 second. We only send a signal to old pids
2317 * if we cannot grab at least one port.
2318 */
2319 retry = MAX_START_RETRIES;
2320 err = ERR_NONE;
2321 while (retry >= 0) {
2322 struct timeval w;
2323 err = start_proxies(retry == 0 || nb_oldpids == 0);
Willy Tarreaue13e9252007-12-20 23:05:50 +01002324 /* exit the loop on no error or fatal error */
2325 if ((err & (ERR_RETRYABLE|ERR_FATAL)) != ERR_RETRYABLE)
Willy Tarreaubaaee002006-06-26 02:48:02 +02002326 break;
Willy Tarreaubb545b42010-08-25 12:58:59 +02002327 if (nb_oldpids == 0 || retry == 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +02002328 break;
2329
2330 /* FIXME-20060514: Solaris and OpenBSD do not support shutdown() on
2331 * listening sockets. So on those platforms, it would be wiser to
2332 * simply send SIGUSR1, which will not be undoable.
2333 */
Willy Tarreaubb545b42010-08-25 12:58:59 +02002334 if (tell_old_pids(SIGTTOU) == 0) {
2335 /* no need to wait if we can't contact old pids */
2336 retry = 0;
2337 continue;
2338 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002339 /* give some time to old processes to stop listening */
2340 w.tv_sec = 0;
2341 w.tv_usec = 10*1000;
2342 select(0, NULL, NULL, NULL, &w);
2343 retry--;
2344 }
2345
2346 /* Note: start_proxies() sends an alert when it fails. */
Willy Tarreau0a3b9d92009-02-04 17:05:23 +01002347 if ((err & ~ERR_WARN) != ERR_NONE) {
Willy Tarreauf68da462009-06-09 14:36:00 +02002348 if (retry != MAX_START_RETRIES && nb_oldpids) {
2349 protocol_unbind_all(); /* cleanup everything we can */
Willy Tarreaubaaee002006-06-26 02:48:02 +02002350 tell_old_pids(SIGTTIN);
Willy Tarreauf68da462009-06-09 14:36:00 +02002351 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002352 exit(1);
2353 }
2354
2355 if (listeners == 0) {
Willy Tarreauf2ee0162015-08-09 11:01:51 +02002356 Alert("[%s.main()] No enabled listener found (check for 'bind' directives) ! Exiting.\n", argv[0]);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002357 /* Note: we don't have to send anything to the old pids because we
2358 * never stopped them. */
2359 exit(1);
2360 }
2361
Emeric Bruncf20bf12010-10-22 16:06:11 +02002362 err = protocol_bind_all(errmsg, sizeof(errmsg));
2363 if ((err & ~ERR_WARN) != ERR_NONE) {
2364 if ((err & ERR_ALERT) || (err & ERR_WARN))
2365 Alert("[%s.main()] %s.\n", argv[0], errmsg);
2366
Willy Tarreaudd815982007-10-16 12:25:14 +02002367 Alert("[%s.main()] Some protocols failed to start their listeners! Exiting.\n", argv[0]);
2368 protocol_unbind_all(); /* cleanup everything we can */
2369 if (nb_oldpids)
2370 tell_old_pids(SIGTTIN);
2371 exit(1);
Emeric Bruncf20bf12010-10-22 16:06:11 +02002372 } else if (err & ERR_WARN) {
2373 Alert("[%s.main()] %s.\n", argv[0], errmsg);
Willy Tarreaudd815982007-10-16 12:25:14 +02002374 }
Olivier Houchardf73629d2017-04-05 22:33:04 +02002375 /* Ok, all listener should now be bound, close any leftover sockets
2376 * the previous process gave us, we don't need them anymore
2377 */
2378 while (xfer_sock_list != NULL) {
2379 struct xfer_sock_list *tmpxfer = xfer_sock_list->next;
2380 close(xfer_sock_list->fd);
2381 free(xfer_sock_list->iface);
2382 free(xfer_sock_list->namespace);
2383 free(xfer_sock_list);
2384 xfer_sock_list = tmpxfer;
2385 }
Willy Tarreaudd815982007-10-16 12:25:14 +02002386
Willy Tarreaubaaee002006-06-26 02:48:02 +02002387 /* prepare pause/play signals */
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002388 signal_register_fct(SIGTTOU, sig_pause, SIGTTOU);
2389 signal_register_fct(SIGTTIN, sig_listen, SIGTTIN);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002390
Willy Tarreaubaaee002006-06-26 02:48:02 +02002391 /* MODE_QUIET can inhibit alerts and warnings below this line */
2392
2393 global.mode &= ~MODE_STARTING;
2394 if ((global.mode & MODE_QUIET) && !(global.mode & MODE_VERBOSE)) {
2395 /* detach from the tty */
2396 fclose(stdin); fclose(stdout); fclose(stderr);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002397 }
2398
2399 /* open log & pid files before the chroot */
William Lallemand095ba4c2017-06-01 17:38:50 +02002400 if (global.mode & MODE_DAEMON && global.pidfile != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002401 unlink(global.pidfile);
2402 pidfd = open(global.pidfile, O_CREAT | O_WRONLY | O_TRUNC, 0644);
2403 if (pidfd < 0) {
2404 Alert("[%s.main()] Cannot create pidfile %s\n", argv[0], global.pidfile);
2405 if (nb_oldpids)
2406 tell_old_pids(SIGTTIN);
Willy Tarreaudd815982007-10-16 12:25:14 +02002407 protocol_unbind_all();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002408 exit(1);
2409 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002410 }
2411
Willy Tarreaub38651a2007-03-24 17:24:39 +01002412 if ((global.last_checks & LSTCHK_NETADM) && global.uid) {
2413 Alert("[%s.main()] Some configuration options require full privileges, so global.uid cannot be changed.\n"
Willy Tarreau4e30ed72009-02-04 18:02:48 +01002414 "", argv[0]);
Willy Tarreaudd815982007-10-16 12:25:14 +02002415 protocol_unbind_all();
Willy Tarreaub38651a2007-03-24 17:24:39 +01002416 exit(1);
2417 }
2418
Willy Tarreau4e30ed72009-02-04 18:02:48 +01002419 /* If the user is not root, we'll still let him try the configuration
2420 * but we inform him that unexpected behaviour may occur.
2421 */
2422 if ((global.last_checks & LSTCHK_NETADM) && getuid())
2423 Warning("[%s.main()] Some options which require full privileges"
2424 " might not work well.\n"
2425 "", argv[0]);
2426
William Lallemand095ba4c2017-06-01 17:38:50 +02002427 if ((global.mode & (MODE_MWORKER|MODE_DAEMON)) == 0) {
2428
2429 /* chroot if needed */
2430 if (global.chroot != NULL) {
2431 if (chroot(global.chroot) == -1 || chdir("/") == -1) {
2432 Alert("[%s.main()] Cannot chroot(%s).\n", argv[0], global.chroot);
2433 if (nb_oldpids)
2434 tell_old_pids(SIGTTIN);
2435 protocol_unbind_all();
2436 exit(1);
2437 }
Willy Tarreauf223cc02007-10-15 18:57:08 +02002438 }
Willy Tarreauf223cc02007-10-15 18:57:08 +02002439 }
2440
Willy Tarreaubaaee002006-06-26 02:48:02 +02002441 if (nb_oldpids)
Willy Tarreaubb545b42010-08-25 12:58:59 +02002442 nb_oldpids = tell_old_pids(oldpids_sig);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002443
William Lallemand8a361b52017-06-20 11:20:33 +02002444 if ((getenv("HAPROXY_MWORKER_REEXEC") == NULL)) {
2445 nb_oldpids = 0;
2446 free(oldpids);
2447 oldpids = NULL;
2448 }
2449
2450
Willy Tarreaubaaee002006-06-26 02:48:02 +02002451 /* Note that any error at this stage will be fatal because we will not
2452 * be able to restart the old pids.
2453 */
2454
William Lallemand095ba4c2017-06-01 17:38:50 +02002455 if ((global.mode & (MODE_MWORKER|MODE_DAEMON)) == 0) {
2456 /* setgid / setuid */
2457 if (global.gid) {
2458 if (getgroups(0, NULL) > 0 && setgroups(0, NULL) == -1)
2459 Warning("[%s.main()] Failed to drop supplementary groups. Using 'gid'/'group'"
2460 " without 'uid'/'user' is generally useless.\n", argv[0]);
2461
2462 if (setgid(global.gid) == -1) {
2463 Alert("[%s.main()] Cannot set gid %d.\n", argv[0], global.gid);
2464 protocol_unbind_all();
2465 exit(1);
2466 }
2467 }
Michael Schererab012dd2013-01-12 18:35:19 +01002468
William Lallemand095ba4c2017-06-01 17:38:50 +02002469 if (global.uid && setuid(global.uid) == -1) {
2470 Alert("[%s.main()] Cannot set uid %d.\n", argv[0], global.uid);
Michael Schererab012dd2013-01-12 18:35:19 +01002471 protocol_unbind_all();
2472 exit(1);
2473 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002474 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002475 /* check ulimits */
2476 limit.rlim_cur = limit.rlim_max = 0;
2477 getrlimit(RLIMIT_NOFILE, &limit);
2478 if (limit.rlim_cur < global.maxsock) {
2479 Warning("[%s.main()] FD limit (%d) too low for maxconn=%d/maxsock=%d. Please raise 'ulimit-n' to %d or more to avoid any trouble.\n",
Willy Tarreau1772ece2009-04-03 14:49:12 +02002480 argv[0], (int)limit.rlim_cur, global.maxconn, global.maxsock, global.maxsock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002481 }
2482
William Lallemand095ba4c2017-06-01 17:38:50 +02002483 if (global.mode & (MODE_DAEMON | MODE_MWORKER)) {
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01002484 struct proxy *px;
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02002485 struct peers *curpeers;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002486 int ret = 0;
2487 int proc;
2488
William Lallemand73b85e72017-06-01 17:38:51 +02002489 children = calloc(global.nbproc, sizeof(int));
William Lallemand095ba4c2017-06-01 17:38:50 +02002490 /*
2491 * if daemon + mworker: must fork here to let a master
2492 * process live in background before forking children
2493 */
William Lallemand73b85e72017-06-01 17:38:51 +02002494
2495 if ((getenv("HAPROXY_MWORKER_REEXEC") == NULL)
2496 && (global.mode & MODE_MWORKER)
2497 && (global.mode & MODE_DAEMON)) {
William Lallemand095ba4c2017-06-01 17:38:50 +02002498 ret = fork();
2499 if (ret < 0) {
2500 Alert("[%s.main()] Cannot fork.\n", argv[0]);
2501 protocol_unbind_all();
2502 exit(1); /* there has been an error */
2503 }
2504 /* parent leave to daemonize */
2505 if (ret > 0)
2506 exit(0);
2507 }
William Lallemande20b6a62017-06-01 17:38:55 +02002508
2509 if (global.mode & MODE_MWORKER) {
2510 if ((getenv("HAPROXY_MWORKER_REEXEC") == NULL)) {
2511 char *msg = NULL;
2512 /* master pipe to ensure the master is still alive */
2513 ret = pipe(mworker_pipe);
2514 if (ret < 0) {
2515 Warning("[%s.main()] Cannot create master pipe.\n", argv[0]);
2516 } else {
2517 memprintf(&msg, "%d", mworker_pipe[0]);
2518 setenv("HAPROXY_MWORKER_PIPE_RD", msg, 1);
2519 memprintf(&msg, "%d", mworker_pipe[1]);
2520 setenv("HAPROXY_MWORKER_PIPE_WR", msg, 1);
2521 free(msg);
2522 }
2523 } else {
2524 mworker_pipe[0] = atol(getenv("HAPROXY_MWORKER_PIPE_RD"));
2525 mworker_pipe[1] = atol(getenv("HAPROXY_MWORKER_PIPE_WR"));
2526 if (mworker_pipe[0] <= 0 || mworker_pipe[1] <= 0) {
2527 Warning("[%s.main()] Cannot get master pipe FDs.\n", argv[0]);
2528 }
2529 }
2530 }
2531
Willy Tarreaubaaee002006-06-26 02:48:02 +02002532 /* the father launches the required number of processes */
2533 for (proc = 0; proc < global.nbproc; proc++) {
2534 ret = fork();
2535 if (ret < 0) {
2536 Alert("[%s.main()] Cannot fork.\n", argv[0]);
Willy Tarreaudd815982007-10-16 12:25:14 +02002537 protocol_unbind_all();
Willy Tarreaud6803712007-10-16 07:44:56 +02002538 exit(1); /* there has been an error */
Willy Tarreaubaaee002006-06-26 02:48:02 +02002539 }
2540 else if (ret == 0) /* child breaks here */
2541 break;
Marc-Antoine Perennou992709b2013-02-12 10:53:52 +01002542 children[proc] = ret;
Willy Tarreau269ab312012-09-05 08:02:48 +02002543 if (pidfd >= 0) {
2544 char pidstr[100];
2545 snprintf(pidstr, sizeof(pidstr), "%d\n", ret);
Willy Tarreau89efaed2013-12-13 15:14:55 +01002546 shut_your_big_mouth_gcc(write(pidfd, pidstr, strlen(pidstr)));
Willy Tarreaubaaee002006-06-26 02:48:02 +02002547 }
Willy Tarreaudcd47712007-11-04 23:35:08 +01002548 relative_pid++; /* each child will get a different one */
Willy Tarreaubaaee002006-06-26 02:48:02 +02002549 }
Willy Tarreaufc6c0322012-11-16 16:12:27 +01002550
2551#ifdef USE_CPU_AFFINITY
2552 if (proc < global.nbproc && /* child */
Willy Tarreaue7597492015-04-20 11:36:57 +02002553 proc < LONGBITS && /* only the first 32/64 processes may be pinned */
Willy Tarreaufc6c0322012-11-16 16:12:27 +01002554 global.cpu_map[proc]) /* only do this if the process has a CPU map */
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +02002555#ifdef __FreeBSD__
Olivier Houchard97148f62017-08-16 17:29:11 +02002556 {
2557 cpuset_t cpuset;
2558 int i;
2559 unsigned long cpu_map = global.cpu_map[proc];
2560
2561 CPU_ZERO(&cpuset);
2562 while ((i = ffsl(cpu_map)) > 0) {
2563 CPU_SET(i - 1, &cpuset);
2564 cpu_map &= ~(1 << (i - 1));
2565 }
2566 ret = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(cpuset), &cpuset);
2567 }
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +02002568#else
Willy Tarreaufc6c0322012-11-16 16:12:27 +01002569 sched_setaffinity(0, sizeof(unsigned long), (void *)&global.cpu_map[proc]);
2570#endif
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +02002571#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +02002572 /* close the pidfile both in children and father */
Willy Tarreau269ab312012-09-05 08:02:48 +02002573 if (pidfd >= 0) {
2574 //lseek(pidfd, 0, SEEK_SET); /* debug: emulate eglibc bug */
2575 close(pidfd);
2576 }
Willy Tarreaud137dd32010-08-25 12:49:05 +02002577
2578 /* We won't ever use this anymore */
Willy Tarreaud137dd32010-08-25 12:49:05 +02002579 free(global.pidfile); global.pidfile = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002580
Willy Tarreauedaff0a2015-05-01 17:01:08 +02002581 if (proc == global.nbproc) {
William Lallemand095ba4c2017-06-01 17:38:50 +02002582 if (global.mode & MODE_MWORKER) {
Willy Tarreauedaff0a2015-05-01 17:01:08 +02002583 protocol_unbind_all();
William Lallemand73b85e72017-06-01 17:38:51 +02002584 mworker_wait();
William Lallemand1499b9b2017-06-07 15:04:47 +02002585 /* should never get there */
2586 exit(EXIT_FAILURE);
Willy Tarreauedaff0a2015-05-01 17:01:08 +02002587 }
William Lallemandcf4e4962017-06-08 19:05:48 +02002588#if defined(USE_OPENSSL) && !defined(OPENSSL_NO_DH)
Grant Zhang872f9c22017-01-21 01:10:18 +00002589 ssl_free_dh();
2590#endif
William Lallemand1499b9b2017-06-07 15:04:47 +02002591 exit(0); /* parent must leave */
Willy Tarreauedaff0a2015-05-01 17:01:08 +02002592 }
2593
William Lallemandcb11fd22017-06-01 17:38:52 +02002594 /* child must never use the atexit function */
2595 atexit_flag = 0;
2596
William Lallemand095ba4c2017-06-01 17:38:50 +02002597 /* Must chroot and setgid/setuid in the children */
2598 /* chroot if needed */
2599 if (global.chroot != NULL) {
2600 if (chroot(global.chroot) == -1 || chdir("/") == -1) {
2601 Alert("[%s.main()] Cannot chroot1(%s).\n", argv[0], global.chroot);
2602 if (nb_oldpids)
2603 tell_old_pids(SIGTTIN);
2604 protocol_unbind_all();
2605 exit(1);
2606 }
2607 }
2608
2609 free(global.chroot);
2610 global.chroot = NULL;
2611
2612 /* setgid / setuid */
2613 if (global.gid) {
2614 if (getgroups(0, NULL) > 0 && setgroups(0, NULL) == -1)
2615 Warning("[%s.main()] Failed to drop supplementary groups. Using 'gid'/'group'"
2616 " without 'uid'/'user' is generally useless.\n", argv[0]);
2617
2618 if (setgid(global.gid) == -1) {
2619 Alert("[%s.main()] Cannot set gid %d.\n", argv[0], global.gid);
2620 protocol_unbind_all();
2621 exit(1);
2622 }
2623 }
2624
2625 if (global.uid && setuid(global.uid) == -1) {
2626 Alert("[%s.main()] Cannot set uid %d.\n", argv[0], global.uid);
2627 protocol_unbind_all();
2628 exit(1);
2629 }
2630
William Lallemand7f80eb22017-05-26 18:19:55 +02002631 /* pass through every cli socket, and check if it's bound to
2632 * the current process and if it exposes listeners sockets.
2633 * Caution: the GTUNE_SOCKET_TRANSFER is now set after the fork.
2634 * */
2635
2636 if (global.stats_fe) {
2637 struct bind_conf *bind_conf;
2638
2639 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
2640 if (bind_conf->level & ACCESS_FD_LISTENERS) {
2641 if (!bind_conf->bind_proc || bind_conf->bind_proc & (1UL << proc)) {
2642 global.tune.options |= GTUNE_SOCKET_TRANSFER;
2643 break;
2644 }
2645 }
2646 }
2647 }
2648
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01002649 /* we might have to unbind some proxies from some processes */
2650 px = proxy;
2651 while (px != NULL) {
2652 if (px->bind_proc && px->state != PR_STSTOPPED) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02002653 if (!(px->bind_proc & (1UL << proc))) {
2654 if (global.tune.options & GTUNE_SOCKET_TRANSFER)
2655 zombify_proxy(px);
2656 else
2657 stop_proxy(px);
2658 }
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01002659 }
2660 px = px->next;
2661 }
2662
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02002663 /* we might have to unbind some peers sections from some processes */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002664 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02002665 if (!curpeers->peers_fe)
2666 continue;
2667
2668 if (curpeers->peers_fe->bind_proc & (1UL << proc))
2669 continue;
2670
2671 stop_proxy(curpeers->peers_fe);
2672 /* disable this peer section so that it kills itself */
Willy Tarreau47c8c022015-09-28 16:39:25 +02002673 signal_unregister_handler(curpeers->sighandler);
2674 task_delete(curpeers->sync_task);
2675 task_free(curpeers->sync_task);
2676 curpeers->sync_task = NULL;
2677 task_free(curpeers->peers_fe->task);
2678 curpeers->peers_fe->task = NULL;
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02002679 curpeers->peers_fe = NULL;
2680 }
2681
Willy Tarreaubaaee002006-06-26 02:48:02 +02002682 /* if we're NOT in QUIET mode, we should now close the 3 first FDs to ensure
2683 * that we can detach from the TTY. We MUST NOT do it in other cases since
2684 * it would have already be done, and 0-2 would have been affected to listening
2685 * sockets
2686 */
Willy Tarreau106cb762008-11-16 07:40:34 +01002687 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002688 /* detach from the tty */
2689 fclose(stdin); fclose(stdout); fclose(stderr);
Willy Tarreau106cb762008-11-16 07:40:34 +01002690 global.mode &= ~MODE_VERBOSE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002691 global.mode |= MODE_QUIET; /* ensure that we won't say anything from now */
2692 }
2693 pid = getpid(); /* update child's pid */
2694 setsid();
Willy Tarreau2ff76222007-04-09 19:29:56 +02002695 fork_poller();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002696 }
2697
William Lallemande20b6a62017-06-01 17:38:55 +02002698 if (global.mode & MODE_MWORKER)
2699 mworker_pipe_register(mworker_pipe);
2700
Willy Tarreaudd815982007-10-16 12:25:14 +02002701 protocol_enable_all();
Willy Tarreau4f60f162007-04-08 16:39:58 +02002702 /*
2703 * That's it : the central polling loop. Run until we stop.
2704 */
2705 run_poll_loop();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002706
Willy Tarreaubaaee002006-06-26 02:48:02 +02002707 /* Do some cleanup */
2708 deinit();
2709
2710 exit(0);
2711}
2712
2713
2714/*
2715 * Local variables:
2716 * c-indent-level: 8
2717 * c-basic-offset: 8
2718 * End:
2719 */