Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Proxy variables and functions. |
| 3 | * |
Willy Tarreau | b7f694f | 2008-06-22 17:18:02 +0200 | [diff] [blame] | 4 | * Copyright 2000-2008 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 5 | * |
| 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 Tarreau | c8f24f8 | 2007-11-30 18:38:35 +0100 | [diff] [blame] | 15 | #include <string.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 16 | #include <sys/types.h> |
| 17 | #include <sys/socket.h> |
| 18 | #include <sys/stat.h> |
| 19 | |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 20 | #include <common/defaults.h> |
Willy Tarreau | 9de1bbd | 2008-07-09 20:34:27 +0200 | [diff] [blame] | 21 | #include <common/cfgparse.h> |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 22 | #include <common/compat.h> |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 23 | #include <common/config.h> |
Willy Tarreau | d740bab | 2007-10-28 11:14:07 +0100 | [diff] [blame] | 24 | #include <common/errors.h> |
Willy Tarreau | 4d2d098 | 2007-05-14 00:39:29 +0200 | [diff] [blame] | 25 | #include <common/memory.h> |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 26 | #include <common/time.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 27 | |
| 28 | #include <types/global.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 29 | |
| 30 | #include <proto/client.h> |
Alexandre Cassen | 87ea548 | 2007-10-11 20:48:58 +0200 | [diff] [blame] | 31 | #include <proto/backend.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 32 | #include <proto/fd.h> |
| 33 | #include <proto/log.h> |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 34 | #include <proto/protocols.h> |
| 35 | #include <proto/proto_tcp.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 36 | #include <proto/proxy.h> |
| 37 | |
| 38 | |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 39 | int listeners; /* # of proxy listeners, set by cfgparse, unset by maintain_proxies */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 40 | struct proxy *proxy = NULL; /* list of all existing proxies */ |
Willy Tarreau | dcd4771 | 2007-11-04 23:35:08 +0100 | [diff] [blame] | 41 | int next_pxid = 1; /* UUID assigned to next new proxy, 0 reserved */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 42 | |
Willy Tarreau | 977b8e4 | 2006-12-29 14:19:17 +0100 | [diff] [blame] | 43 | /* |
Willy Tarreau | 816eb54 | 2007-11-04 07:04:43 +0100 | [diff] [blame] | 44 | * 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 Tarreau | 977b8e4 | 2006-12-29 14:19:17 +0100 | [diff] [blame] | 48 | */ |
Willy Tarreau | 816eb54 | 2007-11-04 07:04:43 +0100 | [diff] [blame] | 49 | const char *proxy_cap_str(int cap) |
Willy Tarreau | 977b8e4 | 2006-12-29 14:19:17 +0100 | [diff] [blame] | 50 | { |
Willy Tarreau | 816eb54 | 2007-11-04 07:04:43 +0100 | [diff] [blame] | 51 | 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 Tarreau | 977b8e4 | 2006-12-29 14:19:17 +0100 | [diff] [blame] | 60 | } |
| 61 | |
Krzysztof Piotr Oledzki | 6eb730d | 2007-11-03 23:41:58 +0100 | [diff] [blame] | 62 | /* |
| 63 | * This function returns a string containing the mode of the proxy in a format |
| 64 | * suitable for error messages. |
| 65 | */ |
Krzysztof Piotr Oledzki | 6eb730d | 2007-11-03 23:41:58 +0100 | [diff] [blame] | 66 | const 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 Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 78 | /* 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 Tarreau | 9de1bbd | 2008-07-09 20:34:27 +0200 | [diff] [blame] | 83 | * command line word, with <proxy> pointing to the proxy being parsed, and |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 84 | * <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 Tarreau | 9de1bbd | 2008-07-09 20:34:27 +0200 | [diff] [blame] | 87 | static int proxy_parse_timeout(char **args, int section, struct proxy *proxy, |
| 88 | struct proxy *defpx, char *err, int errlen) |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 89 | { |
| 90 | unsigned timeout; |
| 91 | int retval, cap; |
| 92 | const char *res, *name; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 93 | int *tv = NULL; |
| 94 | int *td = NULL; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 95 | |
| 96 | retval = 0; |
Willy Tarreau | 9de1bbd | 2008-07-09 20:34:27 +0200 | [diff] [blame] | 97 | |
| 98 | /* simply skip "timeout" but remain compatible with old form */ |
| 99 | if (strcmp(args[0], "timeout") == 0) |
| 100 | args++; |
| 101 | |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 102 | name = args[0]; |
| 103 | if (!strcmp(args[0], "client") || !strcmp(args[0], "clitimeout")) { |
| 104 | name = "client"; |
Willy Tarreau | d7c30f9 | 2007-12-03 01:38:36 +0100 | [diff] [blame] | 105 | tv = &proxy->timeout.client; |
| 106 | td = &defpx->timeout.client; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 107 | cap = PR_CAP_FE; |
| 108 | } else if (!strcmp(args[0], "tarpit")) { |
| 109 | tv = &proxy->timeout.tarpit; |
| 110 | td = &defpx->timeout.tarpit; |
Willy Tarreau | 51c9bde | 2008-01-06 13:40:03 +0100 | [diff] [blame] | 111 | cap = PR_CAP_FE | PR_CAP_BE; |
Willy Tarreau | 036fae0 | 2008-01-06 13:24:40 +0100 | [diff] [blame] | 112 | } else if (!strcmp(args[0], "http-request")) { |
| 113 | tv = &proxy->timeout.httpreq; |
| 114 | td = &defpx->timeout.httpreq; |
| 115 | cap = PR_CAP_FE; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 116 | } else if (!strcmp(args[0], "server") || !strcmp(args[0], "srvtimeout")) { |
| 117 | name = "server"; |
Willy Tarreau | d7c30f9 | 2007-12-03 01:38:36 +0100 | [diff] [blame] | 118 | tv = &proxy->timeout.server; |
| 119 | td = &defpx->timeout.server; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 120 | cap = PR_CAP_BE; |
| 121 | } else if (!strcmp(args[0], "connect") || !strcmp(args[0], "contimeout")) { |
| 122 | name = "connect"; |
Willy Tarreau | d7c30f9 | 2007-12-03 01:38:36 +0100 | [diff] [blame] | 123 | tv = &proxy->timeout.connect; |
| 124 | td = &defpx->timeout.connect; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 125 | cap = PR_CAP_BE; |
Krzysztof Piotr Oledzki | 5259dfe | 2008-01-21 01:54:06 +0100 | [diff] [blame] | 126 | } else if (!strcmp(args[0], "check")) { |
| 127 | tv = &proxy->timeout.check; |
| 128 | td = &defpx->timeout.check; |
| 129 | cap = PR_CAP_BE; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 130 | } else if (!strcmp(args[0], "appsession")) { |
Willy Tarreau | d7c30f9 | 2007-12-03 01:38:36 +0100 | [diff] [blame] | 131 | tv = &proxy->timeout.appsession; |
| 132 | td = &defpx->timeout.appsession; |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 133 | 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 Tarreau | 036fae0 | 2008-01-06 13:24:40 +0100 | [diff] [blame] | 139 | snprintf(err, errlen, |
Krzysztof Piotr Oledzki | 5259dfe | 2008-01-21 01:54:06 +0100 | [diff] [blame] | 140 | "timeout '%s': must be 'client', 'server', 'connect', 'check', " |
Willy Tarreau | 036fae0 | 2008-01-06 13:24:40 +0100 | [diff] [blame] | 141 | "'appsession', 'queue', 'http-request' or 'tarpit'", |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 142 | 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) { |
| 153 | snprintf(err, errlen, "unexpected character '%c' in %s timeout", *err, name); |
| 154 | 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 Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 163 | else if (defpx && *tv != *td) { |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 164 | snprintf(err, errlen, "overwriting %s timeout which was already specified", name); |
| 165 | retval = 1; |
| 166 | } |
| 167 | |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 168 | *tv = MS_TO_TICKS(timeout); |
Willy Tarreau | e219db7 | 2007-12-03 01:30:13 +0100 | [diff] [blame] | 169 | return retval; |
| 170 | } |
| 171 | |
Krzysztof Piotr Oledzki | 6eb730d | 2007-11-03 23:41:58 +0100 | [diff] [blame] | 172 | /* |
| 173 | * This function finds a proxy with matching name, mode and with satisfying |
| 174 | * capabilities. It also checks if there are more matching proxies with |
| 175 | * requested name as this often leads into unexpected situations. |
| 176 | */ |
| 177 | |
| 178 | struct proxy *findproxy(const char *name, int mode, int cap) { |
| 179 | |
Krzysztof Piotr Oledzki | c8b16fc | 2008-02-18 01:26:35 +0100 | [diff] [blame] | 180 | struct proxy *curproxy, *target = NULL; |
Krzysztof Piotr Oledzki | 6eb730d | 2007-11-03 23:41:58 +0100 | [diff] [blame] | 181 | |
| 182 | for (curproxy = proxy; curproxy; curproxy = curproxy->next) { |
| 183 | if ((curproxy->cap & cap)!=cap || strcmp(curproxy->id, name)) |
| 184 | continue; |
| 185 | |
| 186 | if (curproxy->mode != mode) { |
| 187 | Alert("Unable to use proxy '%s' with wrong mode, required: %s, has: %s.\n", |
| 188 | name, proxy_mode_str(mode), proxy_mode_str(curproxy->mode)); |
| 189 | Alert("You may want to use 'mode %s'.\n", proxy_mode_str(mode)); |
| 190 | return NULL; |
| 191 | } |
| 192 | |
| 193 | if (!target) { |
| 194 | target = curproxy; |
| 195 | continue; |
| 196 | } |
| 197 | |
Willy Tarreau | 816eb54 | 2007-11-04 07:04:43 +0100 | [diff] [blame] | 198 | Alert("Refusing to use duplicated proxy '%s' with overlapping capabilities: %s/%s!\n", |
Krzysztof Piotr Oledzki | 6eb730d | 2007-11-03 23:41:58 +0100 | [diff] [blame] | 199 | name, proxy_type_str(curproxy), proxy_type_str(target)); |
| 200 | |
| 201 | return NULL; |
| 202 | } |
| 203 | |
| 204 | return target; |
| 205 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 206 | |
| 207 | /* |
Krzysztof Piotr Oledzki | c8b16fc | 2008-02-18 01:26:35 +0100 | [diff] [blame] | 208 | * This function finds a server with matching name within selected proxy. |
| 209 | * It also checks if there are more matching servers with |
| 210 | * requested name as this often leads into unexpected situations. |
| 211 | */ |
| 212 | |
| 213 | struct server *findserver(const struct proxy *px, const char *name) { |
| 214 | |
| 215 | struct server *cursrv, *target = NULL; |
| 216 | |
| 217 | if (!px) |
| 218 | return NULL; |
| 219 | |
| 220 | for (cursrv = px->srv; cursrv; cursrv = cursrv->next) { |
| 221 | if (strcmp(cursrv->id, name)) |
| 222 | continue; |
| 223 | |
| 224 | if (!target) { |
| 225 | target = cursrv; |
| 226 | continue; |
| 227 | } |
| 228 | |
| 229 | Alert("Refusing to use duplicated server '%s' fould in proxy: %s!\n", |
| 230 | name, px->id); |
| 231 | |
| 232 | return NULL; |
| 233 | } |
| 234 | |
| 235 | return target; |
| 236 | } |
| 237 | |
| 238 | /* |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 239 | * This function creates all proxy sockets. It should be done very early, |
| 240 | * typically before privileges are dropped. The sockets will be registered |
| 241 | * but not added to any fd_set, in order not to loose them across the fork(). |
| 242 | * The proxies also start in IDLE state, meaning that it will be |
| 243 | * maintain_proxies that will finally complete their loading. |
| 244 | * |
| 245 | * Its return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL. |
| 246 | * Retryable errors will only be printed if <verbose> is not zero. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 247 | */ |
| 248 | int start_proxies(int verbose) |
| 249 | { |
| 250 | struct proxy *curproxy; |
| 251 | struct listener *listener; |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 252 | int lerr, err = ERR_NONE; |
| 253 | int pxerr; |
| 254 | char msg[100]; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 255 | |
| 256 | for (curproxy = proxy; curproxy != NULL; curproxy = curproxy->next) { |
| 257 | if (curproxy->state != PR_STNEW) |
| 258 | continue; /* already initialized */ |
| 259 | |
| 260 | pxerr = 0; |
| 261 | for (listener = curproxy->listen; listener != NULL; listener = listener->next) { |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 262 | if (listener->state != LI_ASSIGNED) |
| 263 | continue; /* already started */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 264 | |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 265 | lerr = tcp_bind_listener(listener, msg, sizeof(msg)); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 266 | |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 267 | /* errors are reported if <verbose> is set or if they are fatal */ |
| 268 | if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) { |
| 269 | if (lerr & ERR_ALERT) |
| 270 | Alert("Starting %s %s: %s\n", |
| 271 | proxy_type_str(curproxy), curproxy->id, msg); |
| 272 | else if (lerr & ERR_WARN) |
| 273 | Warning("Starting %s %s: %s\n", |
| 274 | proxy_type_str(curproxy), curproxy->id, msg); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 275 | } |
| 276 | |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 277 | err |= lerr; |
| 278 | if (lerr & (ERR_ABORT | ERR_FATAL)) { |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 279 | pxerr |= 1; |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 280 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 281 | } |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 282 | else if (lerr & ERR_CODE) { |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 283 | pxerr |= 1; |
| 284 | continue; |
| 285 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | if (!pxerr) { |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 289 | curproxy->state = PR_STIDLE; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 290 | send_log(curproxy, LOG_NOTICE, "Proxy %s started.\n", curproxy->id); |
| 291 | } |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 292 | |
| 293 | if (err & ERR_ABORT) |
| 294 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | return err; |
| 298 | } |
| 299 | |
| 300 | |
| 301 | /* |
| 302 | * this function enables proxies when there are enough free sessions, |
| 303 | * or stops them when the table is full. It is designed to be called from the |
Willy Tarreau | 58b458d | 2008-06-29 22:40:23 +0200 | [diff] [blame] | 304 | * select_loop(). It adjusts the date of next expiration event during stop |
| 305 | * time if appropriate. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 306 | */ |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 307 | void maintain_proxies(int *next) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 308 | { |
| 309 | struct proxy *p; |
| 310 | struct listener *l; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 311 | |
| 312 | p = proxy; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 313 | |
| 314 | /* if there are enough free sessions, we'll activate proxies */ |
| 315 | if (actconn < global.maxconn) { |
| 316 | while (p) { |
Willy Tarreau | d5382b4 | 2008-08-16 18:41:13 +0200 | [diff] [blame] | 317 | if (!p->maxconn || p->feconn < p->maxconn) { |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 318 | if (p->state == PR_STIDLE) { |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 319 | for (l = p->listen; l != NULL; l = l->next) |
| 320 | enable_listener(l); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 321 | p->state = PR_STRUN; |
| 322 | } |
| 323 | } |
| 324 | else { |
| 325 | if (p->state == PR_STRUN) { |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 326 | for (l = p->listen; l != NULL; l = l->next) |
| 327 | disable_listener(l); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 328 | p->state = PR_STIDLE; |
| 329 | } |
| 330 | } |
| 331 | p = p->next; |
| 332 | } |
| 333 | } |
| 334 | else { /* block all proxies */ |
| 335 | while (p) { |
| 336 | if (p->state == PR_STRUN) { |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 337 | for (l = p->listen; l != NULL; l = l->next) |
| 338 | disable_listener(l); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 339 | p->state = PR_STIDLE; |
| 340 | } |
| 341 | p = p->next; |
| 342 | } |
| 343 | } |
| 344 | |
| 345 | if (stopping) { |
| 346 | p = proxy; |
| 347 | while (p) { |
| 348 | if (p->state != PR_STSTOPPED) { |
| 349 | int t; |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 350 | t = tick_remain(now_ms, p->stop_time); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 351 | if (t == 0) { |
| 352 | Warning("Proxy %s stopped.\n", p->id); |
| 353 | send_log(p, LOG_WARNING, "Proxy %s stopped.\n", p->id); |
| 354 | |
| 355 | for (l = p->listen; l != NULL; l = l->next) { |
Willy Tarreau | e6b9894 | 2007-10-29 01:09:36 +0100 | [diff] [blame] | 356 | unbind_listener(l); |
| 357 | if (l->state >= LI_ASSIGNED) { |
| 358 | delete_listener(l); |
| 359 | listeners--; |
| 360 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 361 | } |
| 362 | p->state = PR_STSTOPPED; |
Willy Tarreau | 4d2d098 | 2007-05-14 00:39:29 +0200 | [diff] [blame] | 363 | /* try to free more memory */ |
| 364 | pool_gc2(); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 365 | } |
| 366 | else { |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 367 | *next = tick_first(*next, p->stop_time); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 368 | } |
| 369 | } |
| 370 | p = p->next; |
| 371 | } |
| 372 | } |
Willy Tarreau | d825eef | 2007-05-12 22:35:00 +0200 | [diff] [blame] | 373 | return; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 374 | } |
| 375 | |
| 376 | |
| 377 | /* |
| 378 | * this function disables health-check servers so that the process will quickly be ignored |
| 379 | * by load balancers. Note that if a proxy was already in the PAUSED state, then its grace |
| 380 | * time will not be used since it would already not listen anymore to the socket. |
| 381 | */ |
| 382 | void soft_stop(void) |
| 383 | { |
| 384 | struct proxy *p; |
| 385 | |
| 386 | stopping = 1; |
| 387 | p = proxy; |
Willy Tarreau | b0b37bc | 2008-06-23 14:00:57 +0200 | [diff] [blame] | 388 | tv_update_date(0,1); /* else, the old time before select will be used */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 389 | while (p) { |
| 390 | if (p->state != PR_STSTOPPED) { |
| 391 | Warning("Stopping proxy %s in %d ms.\n", p->id, p->grace); |
| 392 | send_log(p, LOG_WARNING, "Stopping proxy %s in %d ms.\n", p->id, p->grace); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 393 | p->stop_time = tick_add(now_ms, p->grace); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 394 | } |
| 395 | p = p->next; |
| 396 | } |
| 397 | } |
| 398 | |
| 399 | |
| 400 | /* |
| 401 | * Linux unbinds the listen socket after a SHUT_RD, and ignores SHUT_WR. |
| 402 | * Solaris refuses either shutdown(). |
| 403 | * OpenBSD ignores SHUT_RD but closes upon SHUT_WR and refuses to rebind. |
| 404 | * So a common validation path involves SHUT_WR && listen && SHUT_RD. |
| 405 | * If disabling at least one listener returns an error, then the proxy |
| 406 | * state is set to PR_STERROR because we don't know how to resume from this. |
| 407 | */ |
| 408 | void pause_proxy(struct proxy *p) |
| 409 | { |
| 410 | struct listener *l; |
| 411 | for (l = p->listen; l != NULL; l = l->next) { |
| 412 | if (shutdown(l->fd, SHUT_WR) == 0 && |
Willy Tarreau | c73ce2b | 2008-01-06 10:55:10 +0100 | [diff] [blame] | 413 | listen(l->fd, p->backlog ? p->backlog : p->maxconn) == 0 && |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 414 | shutdown(l->fd, SHUT_RD) == 0) { |
Willy Tarreau | f161a34 | 2007-04-08 16:59:42 +0200 | [diff] [blame] | 415 | EV_FD_CLR(l->fd, DIR_RD); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 416 | if (p->state != PR_STERROR) |
| 417 | p->state = PR_STPAUSED; |
| 418 | } |
| 419 | else |
| 420 | p->state = PR_STERROR; |
| 421 | } |
| 422 | } |
| 423 | |
| 424 | /* |
| 425 | * This function temporarily disables listening so that another new instance |
| 426 | * can start listening. It is designed to be called upon reception of a |
| 427 | * SIGTTOU, after which either a SIGUSR1 can be sent to completely stop |
| 428 | * the proxy, or a SIGTTIN can be sent to listen again. |
| 429 | */ |
| 430 | void pause_proxies(void) |
| 431 | { |
| 432 | int err; |
| 433 | struct proxy *p; |
| 434 | |
| 435 | err = 0; |
| 436 | p = proxy; |
Willy Tarreau | b0b37bc | 2008-06-23 14:00:57 +0200 | [diff] [blame] | 437 | tv_update_date(0,1); /* else, the old time before select will be used */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 438 | while (p) { |
| 439 | if (p->state != PR_STERROR && |
| 440 | p->state != PR_STSTOPPED && |
| 441 | p->state != PR_STPAUSED) { |
| 442 | Warning("Pausing proxy %s.\n", p->id); |
| 443 | send_log(p, LOG_WARNING, "Pausing proxy %s.\n", p->id); |
| 444 | pause_proxy(p); |
| 445 | if (p->state != PR_STPAUSED) { |
| 446 | err |= 1; |
| 447 | Warning("Proxy %s failed to enter pause mode.\n", p->id); |
| 448 | send_log(p, LOG_WARNING, "Proxy %s failed to enter pause mode.\n", p->id); |
| 449 | } |
| 450 | } |
| 451 | p = p->next; |
| 452 | } |
| 453 | if (err) { |
| 454 | Warning("Some proxies refused to pause, performing soft stop now.\n"); |
| 455 | send_log(p, LOG_WARNING, "Some proxies refused to pause, performing soft stop now.\n"); |
| 456 | soft_stop(); |
| 457 | } |
| 458 | } |
| 459 | |
| 460 | |
| 461 | /* |
| 462 | * This function reactivates listening. This can be used after a call to |
| 463 | * sig_pause(), for example when a new instance has failed starting up. |
| 464 | * It is designed to be called upon reception of a SIGTTIN. |
| 465 | */ |
| 466 | void listen_proxies(void) |
| 467 | { |
| 468 | struct proxy *p; |
| 469 | struct listener *l; |
| 470 | |
| 471 | p = proxy; |
Willy Tarreau | b0b37bc | 2008-06-23 14:00:57 +0200 | [diff] [blame] | 472 | tv_update_date(0,1); /* else, the old time before select will be used */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 473 | while (p) { |
| 474 | if (p->state == PR_STPAUSED) { |
| 475 | Warning("Enabling proxy %s.\n", p->id); |
| 476 | send_log(p, LOG_WARNING, "Enabling proxy %s.\n", p->id); |
| 477 | |
| 478 | for (l = p->listen; l != NULL; l = l->next) { |
Willy Tarreau | c73ce2b | 2008-01-06 10:55:10 +0100 | [diff] [blame] | 479 | if (listen(l->fd, p->backlog ? p->backlog : p->maxconn) == 0) { |
Willy Tarreau | f1221aa | 2006-12-17 22:14:12 +0100 | [diff] [blame] | 480 | if (actconn < global.maxconn && p->feconn < p->maxconn) { |
Willy Tarreau | f161a34 | 2007-04-08 16:59:42 +0200 | [diff] [blame] | 481 | EV_FD_SET(l->fd, DIR_RD); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 482 | p->state = PR_STRUN; |
| 483 | } |
| 484 | else |
| 485 | p->state = PR_STIDLE; |
| 486 | } else { |
| 487 | int port; |
| 488 | |
| 489 | if (l->addr.ss_family == AF_INET6) |
| 490 | port = ntohs(((struct sockaddr_in6 *)(&l->addr))->sin6_port); |
| 491 | else |
| 492 | port = ntohs(((struct sockaddr_in *)(&l->addr))->sin_port); |
| 493 | |
| 494 | Warning("Port %d busy while trying to enable proxy %s.\n", |
| 495 | port, p->id); |
| 496 | send_log(p, LOG_WARNING, "Port %d busy while trying to enable proxy %s.\n", |
| 497 | port, p->id); |
| 498 | /* Another port might have been enabled. Let's stop everything. */ |
| 499 | pause_proxy(p); |
| 500 | break; |
| 501 | } |
| 502 | } |
| 503 | } |
| 504 | p = p->next; |
| 505 | } |
| 506 | } |
| 507 | |
Willy Tarreau | 9de1bbd | 2008-07-09 20:34:27 +0200 | [diff] [blame] | 508 | static struct cfg_kw_list cfg_kws = {{ },{ |
| 509 | { CFG_LISTEN, "timeout", proxy_parse_timeout }, |
| 510 | { CFG_LISTEN, "clitimeout", proxy_parse_timeout }, |
| 511 | { CFG_LISTEN, "contimeout", proxy_parse_timeout }, |
| 512 | { CFG_LISTEN, "srvtimeout", proxy_parse_timeout }, |
| 513 | { 0, NULL, NULL }, |
| 514 | }}; |
| 515 | |
| 516 | __attribute__((constructor)) |
| 517 | static void __proxy_module_init(void) |
| 518 | { |
| 519 | cfg_register_keywords(&cfg_kws); |
| 520 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 521 | |
| 522 | /* |
| 523 | * Local variables: |
| 524 | * c-indent-level: 8 |
| 525 | * c-basic-offset: 8 |
| 526 | * End: |
| 527 | */ |