blob: 69b070e2b4c195000ad6ce04728516b6a81717f2 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Proxy variables and functions.
3 *
Willy Tarreau3a7d2072009-03-05 23:48:25 +01004 * Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <fcntl.h>
14#include <unistd.h>
Willy Tarreauc8f24f82007-11-30 18:38:35 +010015#include <string.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020016#include <sys/types.h>
17#include <sys/socket.h>
18#include <sys/stat.h>
19
Willy Tarreau2dd0d472006-06-29 17:53:05 +020020#include <common/defaults.h>
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020021#include <common/cfgparse.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020022#include <common/compat.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020023#include <common/config.h>
Willy Tarreaud740bab2007-10-28 11:14:07 +010024#include <common/errors.h>
Willy Tarreau4d2d0982007-05-14 00:39:29 +020025#include <common/memory.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020026#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020027
28#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020029
30#include <proto/client.h>
Alexandre Cassen87ea5482007-10-11 20:48:58 +020031#include <proto/backend.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020032#include <proto/fd.h>
33#include <proto/log.h>
Willy Tarreaue6b98942007-10-29 01:09:36 +010034#include <proto/protocols.h>
35#include <proto/proto_tcp.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036#include <proto/proxy.h>
37
38
Willy Tarreaue6b98942007-10-29 01:09:36 +010039int listeners; /* # of proxy listeners, set by cfgparse, unset by maintain_proxies */
Willy Tarreaubaaee002006-06-26 02:48:02 +020040struct proxy *proxy = NULL; /* list of all existing proxies */
Willy Tarreaudcd47712007-11-04 23:35:08 +010041int next_pxid = 1; /* UUID assigned to next new proxy, 0 reserved */
Willy Tarreaubaaee002006-06-26 02:48:02 +020042
Willy Tarreau977b8e42006-12-29 14:19:17 +010043/*
Willy Tarreau816eb542007-11-04 07:04:43 +010044 * This function returns a string containing a name describing capabilities to
45 * report comprehensible error messages. Specifically, it will return the words
46 * "frontend", "backend", "ruleset" when appropriate, or "proxy" for all other
47 * cases including the proxies declared in "listen" mode.
Willy Tarreau977b8e42006-12-29 14:19:17 +010048 */
Willy Tarreau816eb542007-11-04 07:04:43 +010049const char *proxy_cap_str(int cap)
Willy Tarreau977b8e42006-12-29 14:19:17 +010050{
Willy Tarreau816eb542007-11-04 07:04:43 +010051 if ((cap & PR_CAP_LISTEN) != PR_CAP_LISTEN) {
52 if (cap & PR_CAP_FE)
53 return "frontend";
54 else if (cap & PR_CAP_BE)
55 return "backend";
56 else if (cap & PR_CAP_RS)
57 return "ruleset";
58 }
59 return "proxy";
Willy Tarreau977b8e42006-12-29 14:19:17 +010060}
61
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +010062/*
63 * This function returns a string containing the mode of the proxy in a format
64 * suitable for error messages.
65 */
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +010066const char *proxy_mode_str(int mode) {
67
68 if (mode == PR_MODE_TCP)
69 return "tcp";
70 else if (mode == PR_MODE_HTTP)
71 return "http";
72 else if (mode == PR_MODE_HEALTH)
73 return "health";
74 else
75 return "unknown";
76}
77
Willy Tarreaue219db72007-12-03 01:30:13 +010078/* This function parses a "timeout" statement in a proxy section. It returns
79 * -1 if there is any error, 1 for a warning, otherwise zero. If it does not
80 * return zero, it may write an error message into the <err> buffer, for at
81 * most <errlen> bytes, trailing zero included. The trailing '\n' must not
82 * be written. The function must be called with <args> pointing to the first
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020083 * command line word, with <proxy> pointing to the proxy being parsed, and
Willy Tarreaue219db72007-12-03 01:30:13 +010084 * <defpx> to the default proxy or NULL. As a special case for compatibility
85 * with older configs, it also accepts "{cli|srv|con}timeout" in args[0].
86 */
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020087static int proxy_parse_timeout(char **args, int section, struct proxy *proxy,
88 struct proxy *defpx, char *err, int errlen)
Willy Tarreaue219db72007-12-03 01:30:13 +010089{
90 unsigned timeout;
91 int retval, cap;
92 const char *res, *name;
Willy Tarreau0c303ee2008-07-07 00:09:58 +020093 int *tv = NULL;
94 int *td = NULL;
Willy Tarreaue219db72007-12-03 01:30:13 +010095
96 retval = 0;
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020097
98 /* simply skip "timeout" but remain compatible with old form */
99 if (strcmp(args[0], "timeout") == 0)
100 args++;
101
Willy Tarreaue219db72007-12-03 01:30:13 +0100102 name = args[0];
103 if (!strcmp(args[0], "client") || !strcmp(args[0], "clitimeout")) {
104 name = "client";
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100105 tv = &proxy->timeout.client;
106 td = &defpx->timeout.client;
Willy Tarreaue219db72007-12-03 01:30:13 +0100107 cap = PR_CAP_FE;
108 } else if (!strcmp(args[0], "tarpit")) {
109 tv = &proxy->timeout.tarpit;
110 td = &defpx->timeout.tarpit;
Willy Tarreau51c9bde2008-01-06 13:40:03 +0100111 cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau036fae02008-01-06 13:24:40 +0100112 } else if (!strcmp(args[0], "http-request")) {
113 tv = &proxy->timeout.httpreq;
114 td = &defpx->timeout.httpreq;
115 cap = PR_CAP_FE;
Willy Tarreaue219db72007-12-03 01:30:13 +0100116 } else if (!strcmp(args[0], "server") || !strcmp(args[0], "srvtimeout")) {
117 name = "server";
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100118 tv = &proxy->timeout.server;
119 td = &defpx->timeout.server;
Willy Tarreaue219db72007-12-03 01:30:13 +0100120 cap = PR_CAP_BE;
121 } else if (!strcmp(args[0], "connect") || !strcmp(args[0], "contimeout")) {
122 name = "connect";
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100123 tv = &proxy->timeout.connect;
124 td = &defpx->timeout.connect;
Willy Tarreaue219db72007-12-03 01:30:13 +0100125 cap = PR_CAP_BE;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100126 } else if (!strcmp(args[0], "check")) {
127 tv = &proxy->timeout.check;
128 td = &defpx->timeout.check;
129 cap = PR_CAP_BE;
Willy Tarreaue219db72007-12-03 01:30:13 +0100130 } else if (!strcmp(args[0], "appsession")) {
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100131 tv = &proxy->timeout.appsession;
132 td = &defpx->timeout.appsession;
Willy Tarreaue219db72007-12-03 01:30:13 +0100133 cap = PR_CAP_BE;
134 } else if (!strcmp(args[0], "queue")) {
135 tv = &proxy->timeout.queue;
136 td = &defpx->timeout.queue;
137 cap = PR_CAP_BE;
138 } else {
Willy Tarreau036fae02008-01-06 13:24:40 +0100139 snprintf(err, errlen,
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100140 "timeout '%s': must be 'client', 'server', 'connect', 'check', "
Willy Tarreau036fae02008-01-06 13:24:40 +0100141 "'appsession', 'queue', 'http-request' or 'tarpit'",
Willy Tarreaue219db72007-12-03 01:30:13 +0100142 args[0]);
143 return -1;
144 }
145
146 if (*args[1] == 0) {
147 snprintf(err, errlen, "%s timeout expects an integer value (in milliseconds)", name);
148 return -1;
149 }
150
151 res = parse_time_err(args[1], &timeout, TIME_UNIT_MS);
152 if (res) {
Willy Tarreaubb9251e2009-03-06 08:05:40 +0100153 snprintf(err, errlen, "unexpected character '%c' in %s timeout", *res, name);
Willy Tarreaue219db72007-12-03 01:30:13 +0100154 return -1;
155 }
156
157 if (!(proxy->cap & cap)) {
158 snprintf(err, errlen, "%s timeout will be ignored because %s '%s' has no %s capability",
159 name, proxy_type_str(proxy), proxy->id,
160 (cap & PR_CAP_BE) ? "backend" : "frontend");
161 retval = 1;
162 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200163 else if (defpx && *tv != *td) {
Willy Tarreaue219db72007-12-03 01:30:13 +0100164 snprintf(err, errlen, "overwriting %s timeout which was already specified", name);
165 retval = 1;
166 }
167
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200168 *tv = MS_TO_TICKS(timeout);
Willy Tarreaue219db72007-12-03 01:30:13 +0100169 return retval;
170}
171
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100172/* This function parses a "rate-limit" statement in a proxy section. It returns
173 * -1 if there is any error, 1 for a warning, otherwise zero. If it does not
174 * return zero, it may write an error message into the <err> buffer, for at
175 * most <errlen> bytes, trailing zero included. The trailing '\n' must not
176 * be written. The function must be called with <args> pointing to the first
177 * command line word, with <proxy> pointing to the proxy being parsed, and
178 * <defpx> to the default proxy or NULL.
179 */
180static int proxy_parse_rate_limit(char **args, int section, struct proxy *proxy,
181 struct proxy *defpx, char *err, int errlen)
182{
183 int retval, cap;
184 char *res, *name;
185 unsigned int *tv = NULL;
186 unsigned int *td = NULL;
187 unsigned int val;
188
189 retval = 0;
190
191 /* simply skip "rate-limit" */
192 if (strcmp(args[0], "rate-limit") == 0)
193 args++;
194
195 name = args[0];
196 if (!strcmp(args[0], "sessions")) {
197 name = "sessions";
Willy Tarreau13a34bd2009-05-10 18:52:49 +0200198 tv = &proxy->fe_sps_lim;
199 td = &defpx->fe_sps_lim;
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100200 cap = PR_CAP_FE;
201 } else {
202 snprintf(err, errlen,
203 "%s '%s': must be 'sessions'",
204 "rate-limit", args[0]);
205 return -1;
206 }
207
208 if (*args[1] == 0) {
209 snprintf(err, errlen, "%s %s expects expects an integer value (in sessions/second)", "rate-limit", name);
210 return -1;
211 }
212
213 val = strtoul(args[1], &res, 0);
214 if (*res) {
215 snprintf(err, errlen, "%s %s: unexpected character '%c' in integer value '%s'", "rate-limit", name, *res, args[1]);
216 return -1;
217 }
218
219 if (!(proxy->cap & cap)) {
220 snprintf(err, errlen, "%s %s will be ignored because %s '%s' has no %s capability",
221 "rate-limit", name, proxy_type_str(proxy), proxy->id,
222 (cap & PR_CAP_BE) ? "backend" : "frontend");
223 retval = 1;
224 }
225 else if (defpx && *tv != *td) {
226 snprintf(err, errlen, "overwriting %s %s which was already specified", "rate-limit", name);
227 retval = 1;
228 }
229
230 *tv = val;
231 return retval;
232}
233
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100234/*
235 * This function finds a proxy with matching name, mode and with satisfying
236 * capabilities. It also checks if there are more matching proxies with
237 * requested name as this often leads into unexpected situations.
238 */
239
240struct proxy *findproxy(const char *name, int mode, int cap) {
241
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100242 struct proxy *curproxy, *target = NULL;
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100243
244 for (curproxy = proxy; curproxy; curproxy = curproxy->next) {
245 if ((curproxy->cap & cap)!=cap || strcmp(curproxy->id, name))
246 continue;
247
248 if (curproxy->mode != mode) {
249 Alert("Unable to use proxy '%s' with wrong mode, required: %s, has: %s.\n",
250 name, proxy_mode_str(mode), proxy_mode_str(curproxy->mode));
251 Alert("You may want to use 'mode %s'.\n", proxy_mode_str(mode));
252 return NULL;
253 }
254
255 if (!target) {
256 target = curproxy;
257 continue;
258 }
259
Willy Tarreau816eb542007-11-04 07:04:43 +0100260 Alert("Refusing to use duplicated proxy '%s' with overlapping capabilities: %s/%s!\n",
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100261 name, proxy_type_str(curproxy), proxy_type_str(target));
262
263 return NULL;
264 }
265
266 return target;
267}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200268
269/*
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100270 * This function finds a server with matching name within selected proxy.
271 * It also checks if there are more matching servers with
272 * requested name as this often leads into unexpected situations.
273 */
274
275struct server *findserver(const struct proxy *px, const char *name) {
276
277 struct server *cursrv, *target = NULL;
278
279 if (!px)
280 return NULL;
281
282 for (cursrv = px->srv; cursrv; cursrv = cursrv->next) {
283 if (strcmp(cursrv->id, name))
284 continue;
285
286 if (!target) {
287 target = cursrv;
288 continue;
289 }
290
291 Alert("Refusing to use duplicated server '%s' fould in proxy: %s!\n",
292 name, px->id);
293
294 return NULL;
295 }
296
297 return target;
298}
299
Willy Tarreauff01a212009-03-15 13:46:16 +0100300/* This function checks that the designated proxy has no http directives
301 * enabled. It will output a warning if there are, and will fix some of them.
302 * It returns the number of fatal errors encountered. This should be called
303 * at the end of the configuration parsing if the proxy is not in http mode.
304 * The <file> argument is used to construct the error message.
305 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200306int proxy_cfg_ensure_no_http(struct proxy *curproxy)
Willy Tarreauff01a212009-03-15 13:46:16 +0100307{
308 if (curproxy->cookie_name != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200309 Warning("config : cookie will be ignored for %s '%s' (needs 'mode http').\n",
310 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100311 }
312 if (curproxy->rsp_exp != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200313 Warning("config : server regular expressions will be ignored for %s '%s' (needs 'mode http').\n",
314 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100315 }
316 if (curproxy->req_exp != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200317 Warning("config : client regular expressions will be ignored for %s '%s' (needs 'mode http').\n",
318 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100319 }
320 if (curproxy->monitor_uri != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200321 Warning("config : monitor-uri will be ignored for %s '%s' (needs 'mode http').\n",
322 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100323 }
324 if (curproxy->lbprm.algo & BE_LB_PROP_L7) {
325 curproxy->lbprm.algo &= ~BE_LB_ALGO;
326 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200327 Warning("config : Layer 7 hash not possible for %s '%s' (needs 'mode http'). Falling back to round robin.\n",
328 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100329 }
330 return 0;
331}
332
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100333/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200334 * This function creates all proxy sockets. It should be done very early,
335 * typically before privileges are dropped. The sockets will be registered
336 * but not added to any fd_set, in order not to loose them across the fork().
337 * The proxies also start in IDLE state, meaning that it will be
338 * maintain_proxies that will finally complete their loading.
339 *
340 * Its return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
341 * Retryable errors will only be printed if <verbose> is not zero.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200342 */
343int start_proxies(int verbose)
344{
345 struct proxy *curproxy;
346 struct listener *listener;
Willy Tarreaue6b98942007-10-29 01:09:36 +0100347 int lerr, err = ERR_NONE;
348 int pxerr;
349 char msg[100];
Willy Tarreaubaaee002006-06-26 02:48:02 +0200350
351 for (curproxy = proxy; curproxy != NULL; curproxy = curproxy->next) {
352 if (curproxy->state != PR_STNEW)
353 continue; /* already initialized */
354
355 pxerr = 0;
356 for (listener = curproxy->listen; listener != NULL; listener = listener->next) {
Willy Tarreaue6b98942007-10-29 01:09:36 +0100357 if (listener->state != LI_ASSIGNED)
358 continue; /* already started */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200359
Willy Tarreaue6b98942007-10-29 01:09:36 +0100360 lerr = tcp_bind_listener(listener, msg, sizeof(msg));
Willy Tarreaubaaee002006-06-26 02:48:02 +0200361
Willy Tarreaue6b98942007-10-29 01:09:36 +0100362 /* errors are reported if <verbose> is set or if they are fatal */
363 if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
364 if (lerr & ERR_ALERT)
365 Alert("Starting %s %s: %s\n",
366 proxy_type_str(curproxy), curproxy->id, msg);
367 else if (lerr & ERR_WARN)
368 Warning("Starting %s %s: %s\n",
369 proxy_type_str(curproxy), curproxy->id, msg);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200370 }
371
Willy Tarreaue6b98942007-10-29 01:09:36 +0100372 err |= lerr;
373 if (lerr & (ERR_ABORT | ERR_FATAL)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200374 pxerr |= 1;
Willy Tarreaue6b98942007-10-29 01:09:36 +0100375 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200376 }
Willy Tarreaue6b98942007-10-29 01:09:36 +0100377 else if (lerr & ERR_CODE) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200378 pxerr |= 1;
379 continue;
380 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200381 }
382
383 if (!pxerr) {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200384 curproxy->state = PR_STIDLE;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200385 send_log(curproxy, LOG_NOTICE, "Proxy %s started.\n", curproxy->id);
386 }
Willy Tarreaue6b98942007-10-29 01:09:36 +0100387
388 if (err & ERR_ABORT)
389 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200390 }
391
392 return err;
393}
394
395
396/*
397 * this function enables proxies when there are enough free sessions,
398 * or stops them when the table is full. It is designed to be called from the
Willy Tarreau58b458d2008-06-29 22:40:23 +0200399 * select_loop(). It adjusts the date of next expiration event during stop
400 * time if appropriate.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200401 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200402void maintain_proxies(int *next)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200403{
404 struct proxy *p;
405 struct listener *l;
Willy Tarreau79584222009-03-06 09:18:27 +0100406 unsigned int wait;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200407
408 p = proxy;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200409
410 /* if there are enough free sessions, we'll activate proxies */
411 if (actconn < global.maxconn) {
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100412 for (; p; p = p->next) {
413 /* check the various reasons we may find to block the frontend */
414 if (p->feconn >= p->maxconn)
415 goto do_block;
416
Willy Tarreau13a34bd2009-05-10 18:52:49 +0200417 if (p->fe_sps_lim &&
418 (wait = next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0))) {
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100419 /* we're blocking because a limit was reached on the number of
420 * requests/s on the frontend. We want to re-check ASAP, which
Willy Tarreauefcbc6e2009-03-06 08:27:10 +0100421 * means in 1 ms before estimated expiration date, because the
422 * timer will have settled down. Note that we may already be in
423 * IDLE state here.
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100424 */
Willy Tarreauefcbc6e2009-03-06 08:27:10 +0100425 *next = tick_first(*next, tick_add(now_ms, wait));
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100426 goto do_block;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200427 }
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100428
429 /* OK we have no reason to block, so let's unblock if we were blocking */
430 if (p->state == PR_STIDLE) {
431 for (l = p->listen; l != NULL; l = l->next)
432 enable_listener(l);
433 p->state = PR_STRUN;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200434 }
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100435 continue;
436
437 do_block:
438 if (p->state == PR_STRUN) {
439 for (l = p->listen; l != NULL; l = l->next)
440 disable_listener(l);
441 p->state = PR_STIDLE;
442 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200443 }
444 }
445 else { /* block all proxies */
446 while (p) {
447 if (p->state == PR_STRUN) {
Willy Tarreaue6b98942007-10-29 01:09:36 +0100448 for (l = p->listen; l != NULL; l = l->next)
449 disable_listener(l);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200450 p->state = PR_STIDLE;
451 }
452 p = p->next;
453 }
454 }
455
456 if (stopping) {
457 p = proxy;
458 while (p) {
459 if (p->state != PR_STSTOPPED) {
460 int t;
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200461 t = tick_remain(now_ms, p->stop_time);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200462 if (t == 0) {
463 Warning("Proxy %s stopped.\n", p->id);
464 send_log(p, LOG_WARNING, "Proxy %s stopped.\n", p->id);
Willy Tarreauda250db2008-10-12 12:07:48 +0200465 stop_proxy(p);
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200466 /* try to free more memory */
467 pool_gc2();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200468 }
469 else {
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200470 *next = tick_first(*next, p->stop_time);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200471 }
472 }
473 p = p->next;
474 }
475 }
Willy Tarreaud825eef2007-05-12 22:35:00 +0200476 return;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200477}
478
479
480/*
481 * this function disables health-check servers so that the process will quickly be ignored
482 * by load balancers. Note that if a proxy was already in the PAUSED state, then its grace
483 * time will not be used since it would already not listen anymore to the socket.
484 */
485void soft_stop(void)
486{
487 struct proxy *p;
488
489 stopping = 1;
490 p = proxy;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200491 tv_update_date(0,1); /* else, the old time before select will be used */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200492 while (p) {
493 if (p->state != PR_STSTOPPED) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200494 Warning("Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
495 send_log(p, LOG_WARNING, "Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200496 p->stop_time = tick_add(now_ms, p->grace);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200497 }
498 p = p->next;
499 }
500}
501
502
503/*
504 * Linux unbinds the listen socket after a SHUT_RD, and ignores SHUT_WR.
505 * Solaris refuses either shutdown().
506 * OpenBSD ignores SHUT_RD but closes upon SHUT_WR and refuses to rebind.
507 * So a common validation path involves SHUT_WR && listen && SHUT_RD.
508 * If disabling at least one listener returns an error, then the proxy
509 * state is set to PR_STERROR because we don't know how to resume from this.
510 */
511void pause_proxy(struct proxy *p)
512{
513 struct listener *l;
514 for (l = p->listen; l != NULL; l = l->next) {
515 if (shutdown(l->fd, SHUT_WR) == 0 &&
Willy Tarreauc73ce2b2008-01-06 10:55:10 +0100516 listen(l->fd, p->backlog ? p->backlog : p->maxconn) == 0 &&
Willy Tarreaubaaee002006-06-26 02:48:02 +0200517 shutdown(l->fd, SHUT_RD) == 0) {
Willy Tarreauf161a342007-04-08 16:59:42 +0200518 EV_FD_CLR(l->fd, DIR_RD);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200519 if (p->state != PR_STERROR)
520 p->state = PR_STPAUSED;
521 }
522 else
523 p->state = PR_STERROR;
524 }
Willy Tarreauda250db2008-10-12 12:07:48 +0200525}
526
527
528/*
529 * This function completely stops a proxy and releases its listeners. It has
530 * to be called when going down in order to release the ports so that another
531 * process may bind to them. It must also be called on disabled proxies at the
532 * end of start-up. When all listeners are closed, the proxy is set to the
533 * PR_STSTOPPED state.
534 */
535void stop_proxy(struct proxy *p)
536{
537 struct listener *l;
538
539 for (l = p->listen; l != NULL; l = l->next) {
540 unbind_listener(l);
541 if (l->state >= LI_ASSIGNED) {
542 delete_listener(l);
543 listeners--;
544 }
545 }
546 p->state = PR_STSTOPPED;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200547}
548
549/*
550 * This function temporarily disables listening so that another new instance
551 * can start listening. It is designed to be called upon reception of a
552 * SIGTTOU, after which either a SIGUSR1 can be sent to completely stop
553 * the proxy, or a SIGTTIN can be sent to listen again.
554 */
555void pause_proxies(void)
556{
557 int err;
558 struct proxy *p;
559
560 err = 0;
561 p = proxy;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200562 tv_update_date(0,1); /* else, the old time before select will be used */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200563 while (p) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200564 if (p->cap & PR_CAP_FE &&
565 p->state != PR_STERROR &&
Willy Tarreaubaaee002006-06-26 02:48:02 +0200566 p->state != PR_STSTOPPED &&
567 p->state != PR_STPAUSED) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200568 Warning("Pausing %s %s.\n", proxy_cap_str(p->cap), p->id);
569 send_log(p, LOG_WARNING, "Pausing %s %s.\n", proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200570 pause_proxy(p);
571 if (p->state != PR_STPAUSED) {
572 err |= 1;
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200573 Warning("%s %s failed to enter pause mode.\n", proxy_cap_str(p->cap), p->id);
574 send_log(p, LOG_WARNING, "%s %s failed to enter pause mode.\n", proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200575 }
576 }
577 p = p->next;
578 }
579 if (err) {
580 Warning("Some proxies refused to pause, performing soft stop now.\n");
581 send_log(p, LOG_WARNING, "Some proxies refused to pause, performing soft stop now.\n");
582 soft_stop();
583 }
584}
585
586
587/*
588 * This function reactivates listening. This can be used after a call to
589 * sig_pause(), for example when a new instance has failed starting up.
590 * It is designed to be called upon reception of a SIGTTIN.
591 */
592void listen_proxies(void)
593{
594 struct proxy *p;
595 struct listener *l;
596
597 p = proxy;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200598 tv_update_date(0,1); /* else, the old time before select will be used */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200599 while (p) {
600 if (p->state == PR_STPAUSED) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200601 Warning("Enabling %s %s.\n", proxy_cap_str(p->cap), p->id);
602 send_log(p, LOG_WARNING, "Enabling %s %s.\n", proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200603
604 for (l = p->listen; l != NULL; l = l->next) {
Willy Tarreauc73ce2b2008-01-06 10:55:10 +0100605 if (listen(l->fd, p->backlog ? p->backlog : p->maxconn) == 0) {
Willy Tarreauf1221aa2006-12-17 22:14:12 +0100606 if (actconn < global.maxconn && p->feconn < p->maxconn) {
Willy Tarreauf161a342007-04-08 16:59:42 +0200607 EV_FD_SET(l->fd, DIR_RD);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200608 p->state = PR_STRUN;
609 }
610 else
611 p->state = PR_STIDLE;
612 } else {
613 int port;
614
615 if (l->addr.ss_family == AF_INET6)
616 port = ntohs(((struct sockaddr_in6 *)(&l->addr))->sin6_port);
617 else
618 port = ntohs(((struct sockaddr_in *)(&l->addr))->sin_port);
619
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200620 Warning("Port %d busy while trying to enable %s %s.\n",
621 port, proxy_cap_str(p->cap), p->id);
622 send_log(p, LOG_WARNING, "Port %d busy while trying to enable %s %s.\n",
623 port, proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200624 /* Another port might have been enabled. Let's stop everything. */
625 pause_proxy(p);
626 break;
627 }
628 }
629 }
630 p = p->next;
631 }
632}
633
Willy Tarreau9de1bbd2008-07-09 20:34:27 +0200634static struct cfg_kw_list cfg_kws = {{ },{
635 { CFG_LISTEN, "timeout", proxy_parse_timeout },
636 { CFG_LISTEN, "clitimeout", proxy_parse_timeout },
637 { CFG_LISTEN, "contimeout", proxy_parse_timeout },
638 { CFG_LISTEN, "srvtimeout", proxy_parse_timeout },
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100639 { CFG_LISTEN, "rate-limit", proxy_parse_rate_limit },
Willy Tarreau9de1bbd2008-07-09 20:34:27 +0200640 { 0, NULL, NULL },
641}};
642
643__attribute__((constructor))
644static void __proxy_module_init(void)
645{
646 cfg_register_keywords(&cfg_kws);
647}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200648
649/*
650 * Local variables:
651 * c-indent-level: 8
652 * c-basic-offset: 8
653 * End:
654 */