blob: 7dce8c8352e141bff7d9e78c82c5e3e53b3c682f [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>
Willy Tarreau51aecc72009-07-12 09:47:04 +020033#include <proto/hdr_idx.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <proto/log.h>
Willy Tarreaue6b98942007-10-29 01:09:36 +010035#include <proto/protocols.h>
36#include <proto/proto_tcp.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020037#include <proto/proxy.h>
38
39
Willy Tarreaue6b98942007-10-29 01:09:36 +010040int listeners; /* # of proxy listeners, set by cfgparse, unset by maintain_proxies */
Willy Tarreaubaaee002006-06-26 02:48:02 +020041struct proxy *proxy = NULL; /* list of all existing proxies */
Willy Tarreaudcd47712007-11-04 23:35:08 +010042int next_pxid = 1; /* UUID assigned to next new proxy, 0 reserved */
Willy Tarreaubaaee002006-06-26 02:48:02 +020043
Willy Tarreau977b8e42006-12-29 14:19:17 +010044/*
Willy Tarreau816eb542007-11-04 07:04:43 +010045 * This function returns a string containing a name describing capabilities to
46 * report comprehensible error messages. Specifically, it will return the words
47 * "frontend", "backend", "ruleset" when appropriate, or "proxy" for all other
48 * cases including the proxies declared in "listen" mode.
Willy Tarreau977b8e42006-12-29 14:19:17 +010049 */
Willy Tarreau816eb542007-11-04 07:04:43 +010050const char *proxy_cap_str(int cap)
Willy Tarreau977b8e42006-12-29 14:19:17 +010051{
Willy Tarreau816eb542007-11-04 07:04:43 +010052 if ((cap & PR_CAP_LISTEN) != PR_CAP_LISTEN) {
53 if (cap & PR_CAP_FE)
54 return "frontend";
55 else if (cap & PR_CAP_BE)
56 return "backend";
57 else if (cap & PR_CAP_RS)
58 return "ruleset";
59 }
60 return "proxy";
Willy Tarreau977b8e42006-12-29 14:19:17 +010061}
62
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +010063/*
64 * This function returns a string containing the mode of the proxy in a format
65 * suitable for error messages.
66 */
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +010067const char *proxy_mode_str(int mode) {
68
69 if (mode == PR_MODE_TCP)
70 return "tcp";
71 else if (mode == PR_MODE_HTTP)
72 return "http";
73 else if (mode == PR_MODE_HEALTH)
74 return "health";
75 else
76 return "unknown";
77}
78
Willy Tarreaue219db72007-12-03 01:30:13 +010079/* This function parses a "timeout" statement in a proxy section. It returns
80 * -1 if there is any error, 1 for a warning, otherwise zero. If it does not
81 * return zero, it may write an error message into the <err> buffer, for at
82 * most <errlen> bytes, trailing zero included. The trailing '\n' must not
83 * be written. The function must be called with <args> pointing to the first
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020084 * command line word, with <proxy> pointing to the proxy being parsed, and
Willy Tarreaue219db72007-12-03 01:30:13 +010085 * <defpx> to the default proxy or NULL. As a special case for compatibility
86 * with older configs, it also accepts "{cli|srv|con}timeout" in args[0].
87 */
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020088static int proxy_parse_timeout(char **args, int section, struct proxy *proxy,
89 struct proxy *defpx, char *err, int errlen)
Willy Tarreaue219db72007-12-03 01:30:13 +010090{
91 unsigned timeout;
92 int retval, cap;
93 const char *res, *name;
Willy Tarreau0c303ee2008-07-07 00:09:58 +020094 int *tv = NULL;
95 int *td = NULL;
Willy Tarreaue219db72007-12-03 01:30:13 +010096
97 retval = 0;
Willy Tarreau9de1bbd2008-07-09 20:34:27 +020098
99 /* simply skip "timeout" but remain compatible with old form */
100 if (strcmp(args[0], "timeout") == 0)
101 args++;
102
Willy Tarreaue219db72007-12-03 01:30:13 +0100103 name = args[0];
104 if (!strcmp(args[0], "client") || !strcmp(args[0], "clitimeout")) {
105 name = "client";
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100106 tv = &proxy->timeout.client;
107 td = &defpx->timeout.client;
Willy Tarreaue219db72007-12-03 01:30:13 +0100108 cap = PR_CAP_FE;
109 } else if (!strcmp(args[0], "tarpit")) {
110 tv = &proxy->timeout.tarpit;
111 td = &defpx->timeout.tarpit;
Willy Tarreau51c9bde2008-01-06 13:40:03 +0100112 cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau036fae02008-01-06 13:24:40 +0100113 } else if (!strcmp(args[0], "http-request")) {
114 tv = &proxy->timeout.httpreq;
115 td = &defpx->timeout.httpreq;
Willy Tarreaucd7afc02009-07-12 10:03:17 +0200116 cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreaue219db72007-12-03 01:30:13 +0100117 } else if (!strcmp(args[0], "server") || !strcmp(args[0], "srvtimeout")) {
118 name = "server";
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100119 tv = &proxy->timeout.server;
120 td = &defpx->timeout.server;
Willy Tarreaue219db72007-12-03 01:30:13 +0100121 cap = PR_CAP_BE;
122 } else if (!strcmp(args[0], "connect") || !strcmp(args[0], "contimeout")) {
123 name = "connect";
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100124 tv = &proxy->timeout.connect;
125 td = &defpx->timeout.connect;
Willy Tarreaue219db72007-12-03 01:30:13 +0100126 cap = PR_CAP_BE;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100127 } else if (!strcmp(args[0], "check")) {
128 tv = &proxy->timeout.check;
129 td = &defpx->timeout.check;
130 cap = PR_CAP_BE;
Willy Tarreaue219db72007-12-03 01:30:13 +0100131 } else if (!strcmp(args[0], "appsession")) {
Willy Tarreaud7c30f92007-12-03 01:38:36 +0100132 tv = &proxy->timeout.appsession;
133 td = &defpx->timeout.appsession;
Willy Tarreaue219db72007-12-03 01:30:13 +0100134 cap = PR_CAP_BE;
135 } else if (!strcmp(args[0], "queue")) {
136 tv = &proxy->timeout.queue;
137 td = &defpx->timeout.queue;
138 cap = PR_CAP_BE;
139 } else {
Willy Tarreau036fae02008-01-06 13:24:40 +0100140 snprintf(err, errlen,
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100141 "timeout '%s': must be 'client', 'server', 'connect', 'check', "
Willy Tarreau036fae02008-01-06 13:24:40 +0100142 "'appsession', 'queue', 'http-request' or 'tarpit'",
Willy Tarreaue219db72007-12-03 01:30:13 +0100143 args[0]);
144 return -1;
145 }
146
147 if (*args[1] == 0) {
148 snprintf(err, errlen, "%s timeout expects an integer value (in milliseconds)", name);
149 return -1;
150 }
151
152 res = parse_time_err(args[1], &timeout, TIME_UNIT_MS);
153 if (res) {
Willy Tarreaubb9251e2009-03-06 08:05:40 +0100154 snprintf(err, errlen, "unexpected character '%c' in %s timeout", *res, name);
Willy Tarreaue219db72007-12-03 01:30:13 +0100155 return -1;
156 }
157
158 if (!(proxy->cap & cap)) {
159 snprintf(err, errlen, "%s timeout will be ignored because %s '%s' has no %s capability",
160 name, proxy_type_str(proxy), proxy->id,
161 (cap & PR_CAP_BE) ? "backend" : "frontend");
162 retval = 1;
163 }
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200164 else if (defpx && *tv != *td) {
Willy Tarreaue219db72007-12-03 01:30:13 +0100165 snprintf(err, errlen, "overwriting %s timeout which was already specified", name);
166 retval = 1;
167 }
168
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200169 *tv = MS_TO_TICKS(timeout);
Willy Tarreaue219db72007-12-03 01:30:13 +0100170 return retval;
171}
172
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100173/* This function parses a "rate-limit" statement in a proxy section. It returns
174 * -1 if there is any error, 1 for a warning, otherwise zero. If it does not
175 * return zero, it may write an error message into the <err> buffer, for at
176 * most <errlen> bytes, trailing zero included. The trailing '\n' must not
177 * be written. The function must be called with <args> pointing to the first
178 * command line word, with <proxy> pointing to the proxy being parsed, and
179 * <defpx> to the default proxy or NULL.
180 */
181static int proxy_parse_rate_limit(char **args, int section, struct proxy *proxy,
182 struct proxy *defpx, char *err, int errlen)
183{
184 int retval, cap;
185 char *res, *name;
186 unsigned int *tv = NULL;
187 unsigned int *td = NULL;
188 unsigned int val;
189
190 retval = 0;
191
192 /* simply skip "rate-limit" */
193 if (strcmp(args[0], "rate-limit") == 0)
194 args++;
195
196 name = args[0];
197 if (!strcmp(args[0], "sessions")) {
198 name = "sessions";
Willy Tarreau13a34bd2009-05-10 18:52:49 +0200199 tv = &proxy->fe_sps_lim;
200 td = &defpx->fe_sps_lim;
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100201 cap = PR_CAP_FE;
202 } else {
203 snprintf(err, errlen,
204 "%s '%s': must be 'sessions'",
205 "rate-limit", args[0]);
206 return -1;
207 }
208
209 if (*args[1] == 0) {
210 snprintf(err, errlen, "%s %s expects expects an integer value (in sessions/second)", "rate-limit", name);
211 return -1;
212 }
213
214 val = strtoul(args[1], &res, 0);
215 if (*res) {
216 snprintf(err, errlen, "%s %s: unexpected character '%c' in integer value '%s'", "rate-limit", name, *res, args[1]);
217 return -1;
218 }
219
220 if (!(proxy->cap & cap)) {
221 snprintf(err, errlen, "%s %s will be ignored because %s '%s' has no %s capability",
222 "rate-limit", name, proxy_type_str(proxy), proxy->id,
223 (cap & PR_CAP_BE) ? "backend" : "frontend");
224 retval = 1;
225 }
226 else if (defpx && *tv != *td) {
227 snprintf(err, errlen, "overwriting %s %s which was already specified", "rate-limit", name);
228 retval = 1;
229 }
230
231 *tv = val;
232 return retval;
233}
234
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100235/*
236 * This function finds a proxy with matching name, mode and with satisfying
237 * capabilities. It also checks if there are more matching proxies with
238 * requested name as this often leads into unexpected situations.
239 */
240
241struct proxy *findproxy(const char *name, int mode, int cap) {
242
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100243 struct proxy *curproxy, *target = NULL;
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100244
245 for (curproxy = proxy; curproxy; curproxy = curproxy->next) {
246 if ((curproxy->cap & cap)!=cap || strcmp(curproxy->id, name))
247 continue;
248
Willy Tarreau51aecc72009-07-12 09:47:04 +0200249 if (curproxy->mode != mode &&
250 !(curproxy->mode == PR_MODE_HTTP && mode == PR_MODE_TCP)) {
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100251 Alert("Unable to use proxy '%s' with wrong mode, required: %s, has: %s.\n",
252 name, proxy_mode_str(mode), proxy_mode_str(curproxy->mode));
253 Alert("You may want to use 'mode %s'.\n", proxy_mode_str(mode));
254 return NULL;
255 }
256
257 if (!target) {
258 target = curproxy;
259 continue;
260 }
261
Willy Tarreau816eb542007-11-04 07:04:43 +0100262 Alert("Refusing to use duplicated proxy '%s' with overlapping capabilities: %s/%s!\n",
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +0100263 name, proxy_type_str(curproxy), proxy_type_str(target));
264
265 return NULL;
266 }
267
268 return target;
269}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200270
271/*
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100272 * This function finds a server with matching name within selected proxy.
273 * It also checks if there are more matching servers with
274 * requested name as this often leads into unexpected situations.
275 */
276
277struct server *findserver(const struct proxy *px, const char *name) {
278
279 struct server *cursrv, *target = NULL;
280
281 if (!px)
282 return NULL;
283
284 for (cursrv = px->srv; cursrv; cursrv = cursrv->next) {
285 if (strcmp(cursrv->id, name))
286 continue;
287
288 if (!target) {
289 target = cursrv;
290 continue;
291 }
292
293 Alert("Refusing to use duplicated server '%s' fould in proxy: %s!\n",
294 name, px->id);
295
296 return NULL;
297 }
298
299 return target;
300}
301
Willy Tarreauff01a212009-03-15 13:46:16 +0100302/* This function checks that the designated proxy has no http directives
303 * enabled. It will output a warning if there are, and will fix some of them.
304 * It returns the number of fatal errors encountered. This should be called
305 * at the end of the configuration parsing if the proxy is not in http mode.
306 * The <file> argument is used to construct the error message.
307 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200308int proxy_cfg_ensure_no_http(struct proxy *curproxy)
Willy Tarreauff01a212009-03-15 13:46:16 +0100309{
310 if (curproxy->cookie_name != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200311 Warning("config : cookie will be ignored for %s '%s' (needs 'mode http').\n",
312 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100313 }
314 if (curproxy->rsp_exp != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200315 Warning("config : server regular expressions will be ignored for %s '%s' (needs 'mode http').\n",
316 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100317 }
318 if (curproxy->req_exp != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200319 Warning("config : client regular expressions will be ignored for %s '%s' (needs 'mode http').\n",
320 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100321 }
322 if (curproxy->monitor_uri != NULL) {
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200323 Warning("config : monitor-uri will be ignored for %s '%s' (needs 'mode http').\n",
324 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100325 }
326 if (curproxy->lbprm.algo & BE_LB_PROP_L7) {
327 curproxy->lbprm.algo &= ~BE_LB_ALGO;
328 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200329 Warning("config : Layer 7 hash not possible for %s '%s' (needs 'mode http'). Falling back to round robin.\n",
330 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +0100331 }
332 return 0;
333}
334
Krzysztof Piotr Oledzkic8b16fc2008-02-18 01:26:35 +0100335/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200336 * This function creates all proxy sockets. It should be done very early,
337 * typically before privileges are dropped. The sockets will be registered
338 * but not added to any fd_set, in order not to loose them across the fork().
339 * The proxies also start in IDLE state, meaning that it will be
340 * maintain_proxies that will finally complete their loading.
341 *
342 * Its return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
343 * Retryable errors will only be printed if <verbose> is not zero.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200344 */
345int start_proxies(int verbose)
346{
347 struct proxy *curproxy;
348 struct listener *listener;
Willy Tarreaue6b98942007-10-29 01:09:36 +0100349 int lerr, err = ERR_NONE;
350 int pxerr;
351 char msg[100];
Willy Tarreaubaaee002006-06-26 02:48:02 +0200352
353 for (curproxy = proxy; curproxy != NULL; curproxy = curproxy->next) {
354 if (curproxy->state != PR_STNEW)
355 continue; /* already initialized */
356
357 pxerr = 0;
358 for (listener = curproxy->listen; listener != NULL; listener = listener->next) {
Willy Tarreaue6b98942007-10-29 01:09:36 +0100359 if (listener->state != LI_ASSIGNED)
360 continue; /* already started */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200361
Willy Tarreaue6b98942007-10-29 01:09:36 +0100362 lerr = tcp_bind_listener(listener, msg, sizeof(msg));
Willy Tarreaubaaee002006-06-26 02:48:02 +0200363
Willy Tarreaue6b98942007-10-29 01:09:36 +0100364 /* errors are reported if <verbose> is set or if they are fatal */
365 if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
366 if (lerr & ERR_ALERT)
367 Alert("Starting %s %s: %s\n",
368 proxy_type_str(curproxy), curproxy->id, msg);
369 else if (lerr & ERR_WARN)
370 Warning("Starting %s %s: %s\n",
371 proxy_type_str(curproxy), curproxy->id, msg);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200372 }
373
Willy Tarreaue6b98942007-10-29 01:09:36 +0100374 err |= lerr;
375 if (lerr & (ERR_ABORT | ERR_FATAL)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200376 pxerr |= 1;
Willy Tarreaue6b98942007-10-29 01:09:36 +0100377 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200378 }
Willy Tarreaue6b98942007-10-29 01:09:36 +0100379 else if (lerr & ERR_CODE) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200380 pxerr |= 1;
381 continue;
382 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200383 }
384
385 if (!pxerr) {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200386 curproxy->state = PR_STIDLE;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200387 send_log(curproxy, LOG_NOTICE, "Proxy %s started.\n", curproxy->id);
388 }
Willy Tarreaue6b98942007-10-29 01:09:36 +0100389
390 if (err & ERR_ABORT)
391 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200392 }
393
394 return err;
395}
396
397
398/*
399 * this function enables proxies when there are enough free sessions,
400 * or stops them when the table is full. It is designed to be called from the
Willy Tarreau58b458d2008-06-29 22:40:23 +0200401 * select_loop(). It adjusts the date of next expiration event during stop
402 * time if appropriate.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200403 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200404void maintain_proxies(int *next)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200405{
406 struct proxy *p;
407 struct listener *l;
Willy Tarreau79584222009-03-06 09:18:27 +0100408 unsigned int wait;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200409
410 p = proxy;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200411
412 /* if there are enough free sessions, we'll activate proxies */
413 if (actconn < global.maxconn) {
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100414 for (; p; p = p->next) {
415 /* check the various reasons we may find to block the frontend */
416 if (p->feconn >= p->maxconn)
417 goto do_block;
418
Willy Tarreau13a34bd2009-05-10 18:52:49 +0200419 if (p->fe_sps_lim &&
420 (wait = next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0))) {
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100421 /* we're blocking because a limit was reached on the number of
422 * requests/s on the frontend. We want to re-check ASAP, which
Willy Tarreauefcbc6e2009-03-06 08:27:10 +0100423 * means in 1 ms before estimated expiration date, because the
424 * timer will have settled down. Note that we may already be in
425 * IDLE state here.
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100426 */
Willy Tarreauefcbc6e2009-03-06 08:27:10 +0100427 *next = tick_first(*next, tick_add(now_ms, wait));
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100428 goto do_block;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200429 }
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100430
431 /* OK we have no reason to block, so let's unblock if we were blocking */
432 if (p->state == PR_STIDLE) {
433 for (l = p->listen; l != NULL; l = l->next)
434 enable_listener(l);
435 p->state = PR_STRUN;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200436 }
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100437 continue;
438
439 do_block:
440 if (p->state == PR_STRUN) {
441 for (l = p->listen; l != NULL; l = l->next)
442 disable_listener(l);
443 p->state = PR_STIDLE;
444 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200445 }
446 }
447 else { /* block all proxies */
448 while (p) {
449 if (p->state == PR_STRUN) {
Willy Tarreaue6b98942007-10-29 01:09:36 +0100450 for (l = p->listen; l != NULL; l = l->next)
451 disable_listener(l);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200452 p->state = PR_STIDLE;
453 }
454 p = p->next;
455 }
456 }
457
458 if (stopping) {
459 p = proxy;
460 while (p) {
461 if (p->state != PR_STSTOPPED) {
462 int t;
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200463 t = tick_remain(now_ms, p->stop_time);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200464 if (t == 0) {
465 Warning("Proxy %s stopped.\n", p->id);
466 send_log(p, LOG_WARNING, "Proxy %s stopped.\n", p->id);
Willy Tarreauda250db2008-10-12 12:07:48 +0200467 stop_proxy(p);
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200468 /* try to free more memory */
469 pool_gc2();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200470 }
471 else {
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200472 *next = tick_first(*next, p->stop_time);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200473 }
474 }
475 p = p->next;
476 }
477 }
Willy Tarreaud825eef2007-05-12 22:35:00 +0200478 return;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200479}
480
481
482/*
483 * this function disables health-check servers so that the process will quickly be ignored
484 * by load balancers. Note that if a proxy was already in the PAUSED state, then its grace
485 * time will not be used since it would already not listen anymore to the socket.
486 */
487void soft_stop(void)
488{
489 struct proxy *p;
490
491 stopping = 1;
492 p = proxy;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200493 tv_update_date(0,1); /* else, the old time before select will be used */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200494 while (p) {
495 if (p->state != PR_STSTOPPED) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200496 Warning("Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
497 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 +0200498 p->stop_time = tick_add(now_ms, p->grace);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200499 }
500 p = p->next;
501 }
502}
503
504
505/*
506 * Linux unbinds the listen socket after a SHUT_RD, and ignores SHUT_WR.
507 * Solaris refuses either shutdown().
508 * OpenBSD ignores SHUT_RD but closes upon SHUT_WR and refuses to rebind.
509 * So a common validation path involves SHUT_WR && listen && SHUT_RD.
510 * If disabling at least one listener returns an error, then the proxy
511 * state is set to PR_STERROR because we don't know how to resume from this.
512 */
513void pause_proxy(struct proxy *p)
514{
515 struct listener *l;
516 for (l = p->listen; l != NULL; l = l->next) {
517 if (shutdown(l->fd, SHUT_WR) == 0 &&
Willy Tarreauc73ce2b2008-01-06 10:55:10 +0100518 listen(l->fd, p->backlog ? p->backlog : p->maxconn) == 0 &&
Willy Tarreaubaaee002006-06-26 02:48:02 +0200519 shutdown(l->fd, SHUT_RD) == 0) {
Willy Tarreauf161a342007-04-08 16:59:42 +0200520 EV_FD_CLR(l->fd, DIR_RD);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200521 if (p->state != PR_STERROR)
522 p->state = PR_STPAUSED;
523 }
524 else
525 p->state = PR_STERROR;
526 }
Willy Tarreauda250db2008-10-12 12:07:48 +0200527}
528
529
530/*
531 * This function completely stops a proxy and releases its listeners. It has
532 * to be called when going down in order to release the ports so that another
533 * process may bind to them. It must also be called on disabled proxies at the
534 * end of start-up. When all listeners are closed, the proxy is set to the
535 * PR_STSTOPPED state.
536 */
537void stop_proxy(struct proxy *p)
538{
539 struct listener *l;
540
541 for (l = p->listen; l != NULL; l = l->next) {
542 unbind_listener(l);
543 if (l->state >= LI_ASSIGNED) {
544 delete_listener(l);
545 listeners--;
546 }
547 }
548 p->state = PR_STSTOPPED;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200549}
550
551/*
552 * This function temporarily disables listening so that another new instance
553 * can start listening. It is designed to be called upon reception of a
554 * SIGTTOU, after which either a SIGUSR1 can be sent to completely stop
555 * the proxy, or a SIGTTIN can be sent to listen again.
556 */
557void pause_proxies(void)
558{
559 int err;
560 struct proxy *p;
561
562 err = 0;
563 p = proxy;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200564 tv_update_date(0,1); /* else, the old time before select will be used */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200565 while (p) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200566 if (p->cap & PR_CAP_FE &&
567 p->state != PR_STERROR &&
Willy Tarreaubaaee002006-06-26 02:48:02 +0200568 p->state != PR_STSTOPPED &&
569 p->state != PR_STPAUSED) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200570 Warning("Pausing %s %s.\n", proxy_cap_str(p->cap), p->id);
571 send_log(p, LOG_WARNING, "Pausing %s %s.\n", proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200572 pause_proxy(p);
573 if (p->state != PR_STPAUSED) {
574 err |= 1;
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200575 Warning("%s %s failed to enter pause mode.\n", proxy_cap_str(p->cap), p->id);
576 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 +0200577 }
578 }
579 p = p->next;
580 }
581 if (err) {
582 Warning("Some proxies refused to pause, performing soft stop now.\n");
583 send_log(p, LOG_WARNING, "Some proxies refused to pause, performing soft stop now.\n");
584 soft_stop();
585 }
586}
587
588
589/*
590 * This function reactivates listening. This can be used after a call to
591 * sig_pause(), for example when a new instance has failed starting up.
592 * It is designed to be called upon reception of a SIGTTIN.
593 */
594void listen_proxies(void)
595{
596 struct proxy *p;
597 struct listener *l;
598
599 p = proxy;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200600 tv_update_date(0,1); /* else, the old time before select will be used */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200601 while (p) {
602 if (p->state == PR_STPAUSED) {
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200603 Warning("Enabling %s %s.\n", proxy_cap_str(p->cap), p->id);
604 send_log(p, LOG_WARNING, "Enabling %s %s.\n", proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200605
606 for (l = p->listen; l != NULL; l = l->next) {
Willy Tarreauc73ce2b2008-01-06 10:55:10 +0100607 if (listen(l->fd, p->backlog ? p->backlog : p->maxconn) == 0) {
Willy Tarreauf1221aa2006-12-17 22:14:12 +0100608 if (actconn < global.maxconn && p->feconn < p->maxconn) {
Willy Tarreauf161a342007-04-08 16:59:42 +0200609 EV_FD_SET(l->fd, DIR_RD);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200610 p->state = PR_STRUN;
611 }
612 else
613 p->state = PR_STIDLE;
614 } else {
615 int port;
616
617 if (l->addr.ss_family == AF_INET6)
618 port = ntohs(((struct sockaddr_in6 *)(&l->addr))->sin6_port);
619 else
620 port = ntohs(((struct sockaddr_in *)(&l->addr))->sin_port);
621
Willy Tarreauf8fbcef2008-10-10 17:51:34 +0200622 Warning("Port %d busy while trying to enable %s %s.\n",
623 port, proxy_cap_str(p->cap), p->id);
624 send_log(p, LOG_WARNING, "Port %d busy while trying to enable %s %s.\n",
625 port, proxy_cap_str(p->cap), p->id);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200626 /* Another port might have been enabled. Let's stop everything. */
627 pause_proxy(p);
628 break;
629 }
630 }
631 }
632 p = p->next;
633 }
634}
635
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200636/* Set current session's backend to <be>. Nothing is done if the
637 * session already had a backend assigned, which is indicated by
638 * s->flags & SN_BE_ASSIGNED.
639 * All flags, stats and counters which need be updated are updated.
Willy Tarreaubedb9ba2009-07-12 08:27:39 +0200640 * Returns 1 if done, 0 in case of internal error, eg: lack of resource.
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200641 */
Willy Tarreaubedb9ba2009-07-12 08:27:39 +0200642int session_set_backend(struct session *s, struct proxy *be)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200643{
644 if (s->flags & SN_BE_ASSIGNED)
Willy Tarreaubedb9ba2009-07-12 08:27:39 +0200645 return 1;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200646 s->be = be;
647 be->beconn++;
648 if (be->beconn > be->beconn_max)
649 be->beconn_max = be->beconn;
650 proxy_inc_be_ctr(be);
651
652 /* assign new parameters to the session from the new backend */
653 s->rep->rto = s->req->wto = be->timeout.server;
654 s->req->cto = be->timeout.connect;
655 s->conn_retries = be->conn_retries;
656 if (be->options2 & PR_O2_RSPBUG_OK)
657 s->txn.rsp.err_pos = -1; /* let buggy responses pass */
658 s->flags |= SN_BE_ASSIGNED;
Willy Tarreau51aecc72009-07-12 09:47:04 +0200659
660 /* If the target backend requires HTTP processing, we have to allocate
661 * a struct hdr_idx for it if we did not have one.
662 */
663 if (unlikely(!s->txn.hdr_idx.v && (be->acl_requires & ACL_USE_L7_ANY))) {
664 if ((s->txn.hdr_idx.v = pool_alloc2(s->fe->hdr_idx_pool)) == NULL)
665 return 0; /* not enough memory */
666 s->txn.hdr_idx.size = MAX_HTTP_HDR;
667 hdr_idx_init(&s->txn.hdr_idx);
668 }
669
Willy Tarreauc1a21672009-08-16 22:37:44 +0200670 /* We want to enable the backend-specific analysers except those which
671 * were already run as part of the frontend/listener. Note that it would
672 * be more reliable to store the list of analysers that have been run,
673 * but what we do here is OK for now.
Emeric Brun647caf12009-06-30 17:57:00 +0200674 */
Willy Tarreauc1a21672009-08-16 22:37:44 +0200675 s->req->analysers |= be->be_req_ana & ~(s->listener->analysers);
Emeric Brun647caf12009-06-30 17:57:00 +0200676
Willy Tarreaubedb9ba2009-07-12 08:27:39 +0200677 return 1;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200678}
679
Willy Tarreau9de1bbd2008-07-09 20:34:27 +0200680static struct cfg_kw_list cfg_kws = {{ },{
681 { CFG_LISTEN, "timeout", proxy_parse_timeout },
682 { CFG_LISTEN, "clitimeout", proxy_parse_timeout },
683 { CFG_LISTEN, "contimeout", proxy_parse_timeout },
684 { CFG_LISTEN, "srvtimeout", proxy_parse_timeout },
Willy Tarreau3a7d2072009-03-05 23:48:25 +0100685 { CFG_LISTEN, "rate-limit", proxy_parse_rate_limit },
Willy Tarreau9de1bbd2008-07-09 20:34:27 +0200686 { 0, NULL, NULL },
687}};
688
689__attribute__((constructor))
690static void __proxy_module_init(void)
691{
692 cfg_register_keywords(&cfg_kws);
693}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200694
695/*
696 * Local variables:
697 * c-indent-level: 8
698 * c-basic-offset: 8
699 * End:
700 */