blob: c680777435e132a99125fe1e90f1e6f02eca82a9 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Backend variables and functions.
3 *
Willy Tarreau1a7eca12013-01-07 22:38:03 +01004 * Copyright 2000-2013 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 <errno.h>
14#include <fcntl.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <syslog.h>
Willy Tarreauf19cf372006-11-14 15:40:51 +010018#include <string.h>
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +020019#include <ctype.h>
Dmitry Sivachenkocaf58982009-08-24 15:11:06 +040020#include <sys/types.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020021
Willy Tarreauc7e42382012-08-24 19:22:53 +020022#include <common/buffer.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020023#include <common/compat.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020024#include <common/config.h>
Willy Tarreau7c669d72008-06-20 15:04:11 +020025#include <common/debug.h>
Bhaskar98634f02013-10-29 23:30:51 -040026#include <common/hash.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020027#include <common/ticks.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020028#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020029
Willy Tarreaubaaee002006-06-26 02:48:02 +020030#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020031
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +010032#include <proto/acl.h>
Willy Tarreau34db1082012-04-19 17:16:54 +020033#include <proto/arg.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020035#include <proto/channel.h>
Willy Tarreau03fa5df2010-05-24 21:02:37 +020036#include <proto/frontend.h>
Willy Tarreau6b2e11b2009-10-01 07:52:15 +020037#include <proto/lb_chash.h>
Willy Tarreauf09c6602012-02-13 17:12:08 +010038#include <proto/lb_fas.h>
Willy Tarreauf89c1872009-10-01 11:19:37 +020039#include <proto/lb_fwlc.h>
40#include <proto/lb_fwrr.h>
41#include <proto/lb_map.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010042#include <proto/obj_type.h>
Willy Tarreaud4c33c82013-01-07 21:59:07 +010043#include <proto/payload.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020044#include <proto/protocol.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020045#include <proto/proto_http.h>
Willy Tarreaua8f55d52010-05-31 17:44:19 +020046#include <proto/proto_tcp.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020047#include <proto/queue.h>
Willy Tarreaud4c33c82013-01-07 21:59:07 +010048#include <proto/sample.h>
Willy Tarreau7f062c42009-03-05 18:43:00 +010049#include <proto/server.h>
Willy Tarreau7c669d72008-06-20 15:04:11 +020050#include <proto/session.h>
Willy Tarreau75bf2c92012-08-20 17:01:35 +020051#include <proto/raw_sock.h>
Willy Tarreau9e000c62011-03-10 14:03:36 +010052#include <proto/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020053#include <proto/task.h>
54
Bhaskar98634f02013-10-29 23:30:51 -040055/* helper function to invoke the correct hash method */
56static unsigned long gen_hash(const struct proxy* px, const char* key, unsigned long len)
57{
58 unsigned long hash;
59
60 switch (px->lbprm.algo & BE_LB_HASH_FUNC) {
61 case BE_LB_HFCN_DJB2:
62 hash = hash_djb2(key, len);
63 break;
Willy Tarreaua0f42712013-11-14 14:30:35 +010064 case BE_LB_HFCN_WT6:
65 hash = hash_wt6(key, len);
66 break;
Bhaskar98634f02013-10-29 23:30:51 -040067 case BE_LB_HFCN_SDBM:
68 /* this is the default hash function */
69 default:
70 hash = hash_sdbm(key, len);
71 break;
72 }
73
74 return hash;
75}
76
Willy Tarreaubaaee002006-06-26 02:48:02 +020077/*
78 * This function recounts the number of usable active and backup servers for
79 * proxy <p>. These numbers are returned into the p->srv_act and p->srv_bck.
Willy Tarreaub625a082007-11-26 01:15:43 +010080 * This function also recomputes the total active and backup weights. However,
Willy Tarreauf4cca452008-03-08 21:42:54 +010081 * it does not update tot_weight nor tot_used. Use update_backend_weight() for
Willy Tarreaub625a082007-11-26 01:15:43 +010082 * this.
Willy Tarreaubaaee002006-06-26 02:48:02 +020083 */
Willy Tarreauc5d9c802009-10-01 09:17:05 +020084void recount_servers(struct proxy *px)
Willy Tarreaubaaee002006-06-26 02:48:02 +020085{
86 struct server *srv;
87
Willy Tarreau20697042007-11-15 23:26:18 +010088 px->srv_act = px->srv_bck = 0;
89 px->lbprm.tot_wact = px->lbprm.tot_wbck = 0;
Willy Tarreaub625a082007-11-26 01:15:43 +010090 px->lbprm.fbck = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +020091 for (srv = px->srv; srv != NULL; srv = srv->next) {
Willy Tarreaub625a082007-11-26 01:15:43 +010092 if (!srv_is_usable(srv->state, srv->eweight))
93 continue;
94
95 if (srv->state & SRV_BACKUP) {
96 if (!px->srv_bck &&
Willy Tarreauf4cca452008-03-08 21:42:54 +010097 !(px->options & PR_O_USE_ALL_BK))
Willy Tarreaub625a082007-11-26 01:15:43 +010098 px->lbprm.fbck = srv;
99 px->srv_bck++;
100 px->lbprm.tot_wbck += srv->eweight;
101 } else {
102 px->srv_act++;
103 px->lbprm.tot_wact += srv->eweight;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200104 }
105 }
Willy Tarreaub625a082007-11-26 01:15:43 +0100106}
Willy Tarreau20697042007-11-15 23:26:18 +0100107
Willy Tarreaub625a082007-11-26 01:15:43 +0100108/* This function simply updates the backend's tot_weight and tot_used values
109 * after servers weights have been updated. It is designed to be used after
110 * recount_servers() or equivalent.
111 */
Willy Tarreauc5d9c802009-10-01 09:17:05 +0200112void update_backend_weight(struct proxy *px)
Willy Tarreaub625a082007-11-26 01:15:43 +0100113{
Willy Tarreau20697042007-11-15 23:26:18 +0100114 if (px->srv_act) {
115 px->lbprm.tot_weight = px->lbprm.tot_wact;
116 px->lbprm.tot_used = px->srv_act;
117 }
Willy Tarreaub625a082007-11-26 01:15:43 +0100118 else if (px->lbprm.fbck) {
119 /* use only the first backup server */
120 px->lbprm.tot_weight = px->lbprm.fbck->eweight;
121 px->lbprm.tot_used = 1;
Willy Tarreau20697042007-11-15 23:26:18 +0100122 }
123 else {
Willy Tarreaub625a082007-11-26 01:15:43 +0100124 px->lbprm.tot_weight = px->lbprm.tot_wbck;
125 px->lbprm.tot_used = px->srv_bck;
Willy Tarreau20697042007-11-15 23:26:18 +0100126 }
Willy Tarreaub625a082007-11-26 01:15:43 +0100127}
128
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200129/*
130 * This function tries to find a running server for the proxy <px> following
131 * the source hash method. Depending on the number of active/backup servers,
132 * it will either look for active servers, or for backup servers.
133 * If any server is found, it will be returned. If no valid server is found,
134 * NULL is returned.
135 */
136struct server *get_server_sh(struct proxy *px, const char *addr, int len)
137{
138 unsigned int h, l;
139
140 if (px->lbprm.tot_weight == 0)
141 return NULL;
142
143 l = h = 0;
144
145 /* note: we won't hash if there's only one server left */
146 if (px->lbprm.tot_used == 1)
147 goto hash_done;
148
149 while ((l + sizeof (int)) <= len) {
150 h ^= ntohl(*(unsigned int *)(&addr[l]));
151 l += sizeof (int);
152 }
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500153 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100154 h = full_hash(h);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200155 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200156 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
157 return chash_get_server_hash(px, h);
158 else
159 return map_get_server_hash(px, h);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200160}
161
162/*
163 * This function tries to find a running server for the proxy <px> following
164 * the URI hash method. In order to optimize cache hits, the hash computation
165 * ends at the question mark. Depending on the number of active/backup servers,
166 * it will either look for active servers, or for backup servers.
167 * If any server is found, it will be returned. If no valid server is found,
168 * NULL is returned.
169 *
170 * This code was contributed by Guillaume Dallaire, who also selected this hash
171 * algorithm out of a tens because it gave him the best results.
172 *
173 */
174struct server *get_server_uh(struct proxy *px, char *uri, int uri_len)
175{
176 unsigned long hash = 0;
177 int c;
178 int slashes = 0;
Bhaskar98634f02013-10-29 23:30:51 -0400179 const char *start, *end;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200180
181 if (px->lbprm.tot_weight == 0)
182 return NULL;
183
184 /* note: we won't hash if there's only one server left */
185 if (px->lbprm.tot_used == 1)
186 goto hash_done;
187
188 if (px->uri_len_limit)
189 uri_len = MIN(uri_len, px->uri_len_limit);
190
Bhaskar98634f02013-10-29 23:30:51 -0400191 start = end = uri;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200192 while (uri_len--) {
Bhaskar98634f02013-10-29 23:30:51 -0400193 c = *end++;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200194 if (c == '/') {
195 slashes++;
196 if (slashes == px->uri_dirs_depth1) /* depth+1 */
197 break;
198 }
Oskar Stolc8dc41842012-05-19 10:19:54 +0100199 else if (c == '?' && !px->uri_whole)
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200200 break;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200201 }
Bhaskar98634f02013-10-29 23:30:51 -0400202
203 hash = gen_hash(px, start, (end - start));
204
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500205 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100206 hash = full_hash(hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200207 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200208 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
209 return chash_get_server_hash(px, hash);
210 else
211 return map_get_server_hash(px, hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200212}
213
Willy Tarreau01732802007-11-01 22:48:15 +0100214/*
215 * This function tries to find a running server for the proxy <px> following
216 * the URL parameter hash method. It looks for a specific parameter in the
217 * URL and hashes it to compute the server ID. This is useful to optimize
218 * performance by avoiding bounces between servers in contexts where sessions
219 * are shared but cookies are not usable. If the parameter is not found, NULL
220 * is returned. If any server is found, it will be returned. If no valid server
221 * is found, NULL is returned.
Willy Tarreau01732802007-11-01 22:48:15 +0100222 */
223struct server *get_server_ph(struct proxy *px, const char *uri, int uri_len)
224{
225 unsigned long hash = 0;
Bhaskar98634f02013-10-29 23:30:51 -0400226 const char *start, *end;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200227 const char *p;
228 const char *params;
Willy Tarreau01732802007-11-01 22:48:15 +0100229 int plen;
230
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200231 /* when tot_weight is 0 then so is srv_count */
Willy Tarreau20697042007-11-15 23:26:18 +0100232 if (px->lbprm.tot_weight == 0)
Willy Tarreau01732802007-11-01 22:48:15 +0100233 return NULL;
234
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200235 if ((p = memchr(uri, '?', uri_len)) == NULL)
236 return NULL;
237
Willy Tarreau01732802007-11-01 22:48:15 +0100238 p++;
239
240 uri_len -= (p - uri);
241 plen = px->url_param_len;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200242 params = p;
Willy Tarreau01732802007-11-01 22:48:15 +0100243
244 while (uri_len > plen) {
245 /* Look for the parameter name followed by an equal symbol */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200246 if (params[plen] == '=') {
247 if (memcmp(params, px->url_param_name, plen) == 0) {
248 /* OK, we have the parameter here at <params>, and
Willy Tarreau01732802007-11-01 22:48:15 +0100249 * the value after the equal sign, at <p>
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200250 * skip the equal symbol
Willy Tarreau01732802007-11-01 22:48:15 +0100251 */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200252 p += plen + 1;
Bhaskar98634f02013-10-29 23:30:51 -0400253 start = end = p;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200254 uri_len -= plen + 1;
255
Bhaskar98634f02013-10-29 23:30:51 -0400256 while (uri_len && *end != '&') {
Willy Tarreau01732802007-11-01 22:48:15 +0100257 uri_len--;
Bhaskar98634f02013-10-29 23:30:51 -0400258 end++;
Willy Tarreau01732802007-11-01 22:48:15 +0100259 }
Bhaskar98634f02013-10-29 23:30:51 -0400260 hash = gen_hash(px, start, (end - start));
261
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500262 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100263 hash = full_hash(hash);
Bhaskar98634f02013-10-29 23:30:51 -0400264
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200265 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
266 return chash_get_server_hash(px, hash);
267 else
268 return map_get_server_hash(px, hash);
Willy Tarreau01732802007-11-01 22:48:15 +0100269 }
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200270 }
271 /* skip to next parameter */
272 p = memchr(params, '&', uri_len);
273 if (!p)
274 return NULL;
275 p++;
276 uri_len -= (p - params);
277 params = p;
278 }
279 return NULL;
280}
281
282/*
283 * this does the same as the previous server_ph, but check the body contents
284 */
285struct server *get_server_ph_post(struct session *s)
286{
287 unsigned long hash = 0;
288 struct http_txn *txn = &s->txn;
Willy Tarreau7421efb2012-07-02 15:11:27 +0200289 struct channel *req = s->req;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200290 struct http_msg *msg = &txn->req;
291 struct proxy *px = s->be;
292 unsigned int plen = px->url_param_len;
Willy Tarreau124d9912011-03-01 20:30:48 +0100293 unsigned long len = msg->body_len;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200294 const char *params = b_ptr(req->buf, (int)(msg->sov - req->buf->o));
Willy Tarreau157dd632009-12-06 19:18:09 +0100295 const char *p = params;
Bhaskar98634f02013-10-29 23:30:51 -0400296 const char *start, *end;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200297
Willy Tarreau9b28e032012-10-12 23:49:43 +0200298 if (len > buffer_len(req->buf) - msg->sov)
299 len = buffer_len(req->buf) - msg->sov;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200300
Willy Tarreau157dd632009-12-06 19:18:09 +0100301 if (len == 0)
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200302 return NULL;
303
Willy Tarreau157dd632009-12-06 19:18:09 +0100304 if (px->lbprm.tot_weight == 0)
305 return NULL;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200306
307 while (len > plen) {
308 /* Look for the parameter name followed by an equal symbol */
309 if (params[plen] == '=') {
310 if (memcmp(params, px->url_param_name, plen) == 0) {
311 /* OK, we have the parameter here at <params>, and
312 * the value after the equal sign, at <p>
313 * skip the equal symbol
314 */
315 p += plen + 1;
Bhaskar98634f02013-10-29 23:30:51 -0400316 start = end = p;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200317 len -= plen + 1;
318
Bhaskar98634f02013-10-29 23:30:51 -0400319 while (len && *end != '&') {
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200320 if (unlikely(!HTTP_IS_TOKEN(*p))) {
Willy Tarreau157dd632009-12-06 19:18:09 +0100321 /* if in a POST, body must be URI encoded or it's not a URI.
Bhaskar98634f02013-10-29 23:30:51 -0400322 * Do not interpret any possible binary data as a parameter.
Willy Tarreau157dd632009-12-06 19:18:09 +0100323 */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200324 if (likely(HTTP_IS_LWS(*p))) /* eol, uncertain uri len */
325 break;
326 return NULL; /* oh, no; this is not uri-encoded.
327 * This body does not contain parameters.
328 */
329 }
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200330 len--;
Bhaskar98634f02013-10-29 23:30:51 -0400331 end++;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200332 /* should we break if vlen exceeds limit? */
333 }
Bhaskar98634f02013-10-29 23:30:51 -0400334 hash = gen_hash(px, start, (end - start));
335
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500336 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100337 hash = full_hash(hash);
Bhaskar98634f02013-10-29 23:30:51 -0400338
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200339 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
340 return chash_get_server_hash(px, hash);
341 else
342 return map_get_server_hash(px, hash);
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200343 }
344 }
Willy Tarreau01732802007-11-01 22:48:15 +0100345 /* skip to next parameter */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200346 p = memchr(params, '&', len);
Willy Tarreau01732802007-11-01 22:48:15 +0100347 if (!p)
348 return NULL;
349 p++;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200350 len -= (p - params);
351 params = p;
Willy Tarreau01732802007-11-01 22:48:15 +0100352 }
353 return NULL;
354}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200355
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200356
Willy Tarreaubaaee002006-06-26 02:48:02 +0200357/*
Benoitaffb4812009-03-25 13:02:10 +0100358 * This function tries to find a running server for the proxy <px> following
359 * the Header parameter hash method. It looks for a specific parameter in the
360 * URL and hashes it to compute the server ID. This is useful to optimize
361 * performance by avoiding bounces between servers in contexts where sessions
362 * are shared but cookies are not usable. If the parameter is not found, NULL
363 * is returned. If any server is found, it will be returned. If no valid server
364 * is found, NULL is returned.
365 */
366struct server *get_server_hh(struct session *s)
367{
368 unsigned long hash = 0;
369 struct http_txn *txn = &s->txn;
Benoitaffb4812009-03-25 13:02:10 +0100370 struct proxy *px = s->be;
371 unsigned int plen = px->hh_len;
372 unsigned long len;
373 struct hdr_ctx ctx;
374 const char *p;
Bhaskar98634f02013-10-29 23:30:51 -0400375 const char *start, *end;
Benoitaffb4812009-03-25 13:02:10 +0100376
377 /* tot_weight appears to mean srv_count */
378 if (px->lbprm.tot_weight == 0)
379 return NULL;
380
Benoitaffb4812009-03-25 13:02:10 +0100381 ctx.idx = 0;
382
383 /* if the message is chunked, we skip the chunk size, but use the value as len */
Willy Tarreau9b28e032012-10-12 23:49:43 +0200384 http_find_header2(px->hh_name, plen, b_ptr(s->req->buf, (int)-s->req->buf->o), &txn->hdr_idx, &ctx);
Benoitaffb4812009-03-25 13:02:10 +0100385
386 /* if the header is not found or empty, let's fallback to round robin */
387 if (!ctx.idx || !ctx.vlen)
388 return NULL;
389
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200390 /* note: we won't hash if there's only one server left */
391 if (px->lbprm.tot_used == 1)
392 goto hash_done;
393
Benoitaffb4812009-03-25 13:02:10 +0100394 /* Found a the hh_name in the headers.
395 * we will compute the hash based on this value ctx.val.
396 */
397 len = ctx.vlen;
398 p = (char *)ctx.line + ctx.val;
399 if (!px->hh_match_domain) {
Bhaskar98634f02013-10-29 23:30:51 -0400400 hash = gen_hash(px, p, len);
Benoitaffb4812009-03-25 13:02:10 +0100401 } else {
402 int dohash = 0;
403 p += len - 1;
Bhaskar98634f02013-10-29 23:30:51 -0400404 start = end = p;
Benoitaffb4812009-03-25 13:02:10 +0100405 /* special computation, use only main domain name, not tld/host
406 * going back from the end of string, start hashing at first
407 * dot stop at next.
408 * This is designed to work with the 'Host' header, and requires
409 * a special option to activate this.
410 */
411 while (len) {
412 if (*p == '.') {
Bhaskar98634f02013-10-29 23:30:51 -0400413 if (!dohash) {
Benoitaffb4812009-03-25 13:02:10 +0100414 dohash = 1;
Bhaskar98634f02013-10-29 23:30:51 -0400415 start = end = p - 1;
416 }
Benoitaffb4812009-03-25 13:02:10 +0100417 else
418 break;
419 } else {
420 if (dohash)
Bhaskar98634f02013-10-29 23:30:51 -0400421 start--;
Benoitaffb4812009-03-25 13:02:10 +0100422 }
423 len--;
424 p--;
425 }
Bhaskar98634f02013-10-29 23:30:51 -0400426 hash = gen_hash(px, start, (end - start));
Benoitaffb4812009-03-25 13:02:10 +0100427 }
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500428 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100429 hash = full_hash(hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200430 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200431 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
432 return chash_get_server_hash(px, hash);
433 else
434 return map_get_server_hash(px, hash);
Benoitaffb4812009-03-25 13:02:10 +0100435}
436
Willy Tarreau34db1082012-04-19 17:16:54 +0200437/* RDP Cookie HASH. */
Emeric Brun736aa232009-06-30 17:56:00 +0200438struct server *get_server_rch(struct session *s)
439{
440 unsigned long hash = 0;
441 struct proxy *px = s->be;
442 unsigned long len;
Emeric Brun736aa232009-06-30 17:56:00 +0200443 int ret;
Willy Tarreau37406352012-04-23 16:16:37 +0200444 struct sample smp;
Willy Tarreaud1de8af2012-05-18 22:12:14 +0200445 int rewind;
Emeric Brun736aa232009-06-30 17:56:00 +0200446
447 /* tot_weight appears to mean srv_count */
448 if (px->lbprm.tot_weight == 0)
449 return NULL;
450
Willy Tarreau37406352012-04-23 16:16:37 +0200451 memset(&smp, 0, sizeof(smp));
Emeric Brun736aa232009-06-30 17:56:00 +0200452
Willy Tarreau9b28e032012-10-12 23:49:43 +0200453 b_rew(s->req->buf, rewind = s->req->buf->o);
Willy Tarreaud1de8af2012-05-18 22:12:14 +0200454
Willy Tarreaucadd8c92013-07-22 18:09:52 +0200455 ret = fetch_rdp_cookie_name(s, &smp, px->hh_name, px->hh_len);
Willy Tarreauf853c462012-04-23 18:53:56 +0200456 len = smp.data.str.len;
Willy Tarreau664092c2011-12-16 19:11:42 +0100457
Willy Tarreau9b28e032012-10-12 23:49:43 +0200458 b_adv(s->req->buf, rewind);
Willy Tarreaud1de8af2012-05-18 22:12:14 +0200459
Willy Tarreau37406352012-04-23 16:16:37 +0200460 if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || len == 0)
Emeric Brun736aa232009-06-30 17:56:00 +0200461 return NULL;
462
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200463 /* note: we won't hash if there's only one server left */
464 if (px->lbprm.tot_used == 1)
465 goto hash_done;
466
Emeric Brun736aa232009-06-30 17:56:00 +0200467 /* Found a the hh_name in the headers.
468 * we will compute the hash based on this value ctx.val.
469 */
Bhaskar98634f02013-10-29 23:30:51 -0400470 hash = gen_hash(px, smp.data.str.str, len);
471
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500472 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100473 hash = full_hash(hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200474 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200475 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
476 return chash_get_server_hash(px, hash);
477 else
478 return map_get_server_hash(px, hash);
Emeric Brun736aa232009-06-30 17:56:00 +0200479}
Benoitaffb4812009-03-25 13:02:10 +0100480
481/*
Willy Tarreau7c669d72008-06-20 15:04:11 +0200482 * This function applies the load-balancing algorithm to the session, as
483 * defined by the backend it is assigned to. The session is then marked as
484 * 'assigned'.
485 *
486 * This function MAY NOT be called with SN_ASSIGNED already set. If the session
487 * had a server previously assigned, it is rebalanced, trying to avoid the same
Willy Tarreau827aee92011-03-10 16:55:02 +0100488 * server, which should still be present in target_srv(&s->target) before the call.
Willy Tarreau7c669d72008-06-20 15:04:11 +0200489 * The function tries to keep the original connection slot if it reconnects to
490 * the same server, otherwise it releases it and tries to offer it.
491 *
492 * It is illegal to call this function with a session in a queue.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200493 *
494 * It may return :
Willy Tarreau664beb82011-03-10 11:38:29 +0100495 * SRV_STATUS_OK if everything is OK. ->srv and ->target are assigned.
Willy Tarreau7c669d72008-06-20 15:04:11 +0200496 * SRV_STATUS_NOSRV if no server is available. Session is not ASSIGNED
497 * SRV_STATUS_FULL if all servers are saturated. Session is not ASSIGNED
Willy Tarreaubaaee002006-06-26 02:48:02 +0200498 * SRV_STATUS_INTERNAL for other unrecoverable errors.
499 *
Willy Tarreau7c669d72008-06-20 15:04:11 +0200500 * Upon successful return, the session flag SN_ASSIGNED is set to indicate that
Willy Tarreau827aee92011-03-10 16:55:02 +0100501 * it does not need to be called anymore. This means that target_srv(&s->target)
502 * can be trusted in balance and direct modes.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200503 *
504 */
505
506int assign_server(struct session *s)
507{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200508 struct connection *conn;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200509 struct server *conn_slot;
Willy Tarreau827aee92011-03-10 16:55:02 +0100510 struct server *srv, *prev_srv;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200511 int err;
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100512
Simon Horman8effd3d2011-08-13 08:03:52 +0900513 DPRINTF(stderr,"assign_server : s=%p\n",s);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200514
Willy Tarreau7c669d72008-06-20 15:04:11 +0200515 err = SRV_STATUS_INTERNAL;
516 if (unlikely(s->pend_pos || s->flags & SN_ASSIGNED))
517 goto out_err;
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100518
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100519 prev_srv = objt_server(s->target);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200520 conn_slot = s->srv_conn;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200521
Willy Tarreau7c669d72008-06-20 15:04:11 +0200522 /* We have to release any connection slot before applying any LB algo,
523 * otherwise we may erroneously end up with no available slot.
524 */
525 if (conn_slot)
526 sess_change_server(s, NULL);
527
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100528 /* We will now try to find the good server and store it into <objt_server(s->target)>.
529 * Note that <objt_server(s->target)> may be NULL in case of dispatch or proxy mode,
Willy Tarreau7c669d72008-06-20 15:04:11 +0200530 * as well as if no server is available (check error code).
531 */
Willy Tarreau1a20a5d2007-11-01 21:08:19 +0100532
Willy Tarreau827aee92011-03-10 16:55:02 +0100533 srv = NULL;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100534 s->target = NULL;
Willy Tarreau664beb82011-03-10 11:38:29 +0100535
Willy Tarreauf3e49f92009-10-03 12:21:20 +0200536 if (s->be->lbprm.algo & BE_LB_KIND) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200537 /* we must check if we have at least one server available */
538 if (!s->be->lbprm.tot_weight) {
539 err = SRV_STATUS_NOSRV;
540 goto out;
541 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200542
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200543 /* First check whether we need to fetch some data or simply call
544 * the LB lookup function. Only the hashing functions will need
545 * some input data in fact, and will support multiple algorithms.
546 */
547 switch (s->be->lbprm.algo & BE_LB_LKUP) {
548 case BE_LB_LKUP_RRTREE:
Willy Tarreau827aee92011-03-10 16:55:02 +0100549 srv = fwrr_get_next_server(s->be, prev_srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200550 break;
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200551
Willy Tarreauf09c6602012-02-13 17:12:08 +0100552 case BE_LB_LKUP_FSTREE:
553 srv = fas_get_next_server(s->be, prev_srv);
554 break;
555
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200556 case BE_LB_LKUP_LCTREE:
Willy Tarreau827aee92011-03-10 16:55:02 +0100557 srv = fwlc_get_next_server(s->be, prev_srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200558 break;
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200559
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200560 case BE_LB_LKUP_CHTREE:
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200561 case BE_LB_LKUP_MAP:
Willy Tarreau9757a382009-10-03 12:56:50 +0200562 if ((s->be->lbprm.algo & BE_LB_KIND) == BE_LB_KIND_RR) {
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200563 if (s->be->lbprm.algo & BE_LB_LKUP_CHTREE)
Willy Tarreau827aee92011-03-10 16:55:02 +0100564 srv = chash_get_next_server(s->be, prev_srv);
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200565 else
Willy Tarreau827aee92011-03-10 16:55:02 +0100566 srv = map_get_server_rr(s->be, prev_srv);
Willy Tarreau9757a382009-10-03 12:56:50 +0200567 break;
568 }
569 else if ((s->be->lbprm.algo & BE_LB_KIND) != BE_LB_KIND_HI) {
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200570 /* unknown balancing algorithm */
Willy Tarreau7c669d72008-06-20 15:04:11 +0200571 err = SRV_STATUS_INTERNAL;
572 goto out;
573 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200574
575 switch (s->be->lbprm.algo & BE_LB_PARM) {
576 case BE_LB_HASH_SRC:
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200577 conn = objt_conn(s->req->prod->end);
578 if (conn && conn->addr.from.ss_family == AF_INET) {
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200579 srv = get_server_sh(s->be,
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200580 (void *)&((struct sockaddr_in *)&conn->addr.from)->sin_addr,
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200581 4);
582 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200583 else if (conn && conn->addr.from.ss_family == AF_INET6) {
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200584 srv = get_server_sh(s->be,
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200585 (void *)&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr,
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200586 16);
587 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200588 else {
589 /* unknown IP family */
590 err = SRV_STATUS_INTERNAL;
591 goto out;
592 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200593 break;
594
595 case BE_LB_HASH_URI:
596 /* URI hashing */
Willy Tarreaueaed5a12010-03-24 14:54:30 +0100597 if (s->txn.req.msg_state < HTTP_MSG_BODY)
598 break;
Willy Tarreau827aee92011-03-10 16:55:02 +0100599 srv = get_server_uh(s->be,
Willy Tarreau9b28e032012-10-12 23:49:43 +0200600 b_ptr(s->req->buf, (int)(s->txn.req.sl.rq.u - s->req->buf->o)),
Willy Tarreau827aee92011-03-10 16:55:02 +0100601 s->txn.req.sl.rq.u_l);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200602 break;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200603
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200604 case BE_LB_HASH_PRM:
605 /* URL Parameter hashing */
Willy Tarreaueaed5a12010-03-24 14:54:30 +0100606 if (s->txn.req.msg_state < HTTP_MSG_BODY)
607 break;
Willy Tarreau61a21a32011-03-01 20:35:49 +0100608
Willy Tarreau827aee92011-03-10 16:55:02 +0100609 srv = get_server_ph(s->be,
Willy Tarreau9b28e032012-10-12 23:49:43 +0200610 b_ptr(s->req->buf, (int)(s->txn.req.sl.rq.u - s->req->buf->o)),
Willy Tarreau827aee92011-03-10 16:55:02 +0100611 s->txn.req.sl.rq.u_l);
Willy Tarreau61a21a32011-03-01 20:35:49 +0100612
Willy Tarreau827aee92011-03-10 16:55:02 +0100613 if (!srv && s->txn.meth == HTTP_METH_POST)
614 srv = get_server_ph_post(s);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200615 break;
Benoitaffb4812009-03-25 13:02:10 +0100616
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200617 case BE_LB_HASH_HDR:
618 /* Header Parameter hashing */
Willy Tarreaueaed5a12010-03-24 14:54:30 +0100619 if (s->txn.req.msg_state < HTTP_MSG_BODY)
620 break;
Willy Tarreau827aee92011-03-10 16:55:02 +0100621 srv = get_server_hh(s);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200622 break;
623
624 case BE_LB_HASH_RDP:
625 /* RDP Cookie hashing */
Willy Tarreau827aee92011-03-10 16:55:02 +0100626 srv = get_server_rch(s);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200627 break;
628
629 default:
630 /* unknown balancing algorithm */
631 err = SRV_STATUS_INTERNAL;
632 goto out;
Benoitaffb4812009-03-25 13:02:10 +0100633 }
Emeric Brun736aa232009-06-30 17:56:00 +0200634
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200635 /* If the hashing parameter was not found, let's fall
636 * back to round robin on the map.
637 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100638 if (!srv) {
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200639 if (s->be->lbprm.algo & BE_LB_LKUP_CHTREE)
Willy Tarreau827aee92011-03-10 16:55:02 +0100640 srv = chash_get_next_server(s->be, prev_srv);
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200641 else
Willy Tarreau827aee92011-03-10 16:55:02 +0100642 srv = map_get_server_rr(s->be, prev_srv);
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200643 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200644
645 /* end of map-based LB */
Emeric Brun736aa232009-06-30 17:56:00 +0200646 break;
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200647
Willy Tarreau7c669d72008-06-20 15:04:11 +0200648 default:
649 /* unknown balancing algorithm */
650 err = SRV_STATUS_INTERNAL;
651 goto out;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200652 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200653
Willy Tarreau827aee92011-03-10 16:55:02 +0100654 if (!srv) {
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200655 err = SRV_STATUS_FULL;
656 goto out;
657 }
Willy Tarreau827aee92011-03-10 16:55:02 +0100658 else if (srv != prev_srv) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100659 s->be->be_counters.cum_lbconn++;
Willy Tarreau827aee92011-03-10 16:55:02 +0100660 srv->counters.cum_lbconn++;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100661 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100662 s->target = &srv->obj_type;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200663 }
Willy Tarreau1620ec32011-08-06 17:05:02 +0200664 else if (s->be->options & (PR_O_DISPATCH | PR_O_TRANSP)) {
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100665 s->target = &s->be->obj_type;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200666 }
David du Colombier6f5ccb12011-03-10 22:26:24 +0100667 else if ((s->be->options & PR_O_HTTP_PROXY) &&
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200668 (conn = objt_conn(s->req->cons->end)) &&
669 is_addr(&conn->addr.to)) {
Willy Tarreau664beb82011-03-10 11:38:29 +0100670 /* in proxy mode, we need a valid destination address */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100671 s->target = &s->be->obj_type;
Willy Tarreau664beb82011-03-10 11:38:29 +0100672 }
673 else {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200674 err = SRV_STATUS_NOSRV;
675 goto out;
676 }
677
678 s->flags |= SN_ASSIGNED;
679 err = SRV_STATUS_OK;
680 out:
681
682 /* Either we take back our connection slot, or we offer it to someone
683 * else if we don't need it anymore.
684 */
685 if (conn_slot) {
Willy Tarreau827aee92011-03-10 16:55:02 +0100686 if (conn_slot == srv) {
687 sess_change_server(s, srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200688 } else {
689 if (may_dequeue_tasks(conn_slot, s->be))
690 process_srv_queue(conn_slot);
691 }
692 }
693
694 out_err:
695 return err;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200696}
697
698
699/*
700 * This function assigns a server address to a session, and sets SN_ADDR_SET.
701 * The address is taken from the currently assigned server, or from the
702 * dispatch or transparent address.
703 *
704 * It may return :
705 * SRV_STATUS_OK if everything is OK.
706 * SRV_STATUS_INTERNAL for other unrecoverable errors.
707 *
708 * Upon successful return, the session flag SN_ADDR_SET is set. This flag is
709 * not cleared, so it's to the caller to clear it if required.
710 *
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200711 * The caller is responsible for having already assigned a connection
712 * to si->end.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200713 *
Willy Tarreaubaaee002006-06-26 02:48:02 +0200714 */
715int assign_server_address(struct session *s)
716{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200717 struct connection *cli_conn = objt_conn(s->req->prod->end);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200718 struct connection *srv_conn = objt_conn(s->req->cons->end);
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200719
Willy Tarreaubaaee002006-06-26 02:48:02 +0200720#ifdef DEBUG_FULL
721 fprintf(stderr,"assign_server_address : s=%p\n",s);
722#endif
723
Willy Tarreauf3e49f92009-10-03 12:21:20 +0200724 if ((s->flags & SN_DIRECT) || (s->be->lbprm.algo & BE_LB_KIND)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200725 /* A server is necessarily known for this session */
726 if (!(s->flags & SN_ASSIGNED))
727 return SRV_STATUS_INTERNAL;
728
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200729 srv_conn->addr.to = objt_server(s->target)->addr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200730
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200731 if (!is_addr(&srv_conn->addr.to) && cli_conn) {
Willy Tarreaud669a4f2010-07-13 14:49:50 +0200732 /* if the server has no address, we use the same address
733 * the client asked, which is handy for remapping ports
734 * locally on multiple addresses at once.
735 */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200736 conn_get_to_addr(cli_conn);
Willy Tarreaud669a4f2010-07-13 14:49:50 +0200737
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200738 if (cli_conn->addr.to.ss_family == AF_INET) {
739 ((struct sockaddr_in *)&srv_conn->addr.to)->sin_addr = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
740 } else if (cli_conn->addr.to.ss_family == AF_INET6) {
741 ((struct sockaddr_in6 *)&srv_conn->addr.to)->sin6_addr = ((struct sockaddr_in6 *)&cli_conn->addr.to)->sin6_addr;
Emeric Brunec810d12010-10-22 16:36:33 +0200742 }
Willy Tarreaud669a4f2010-07-13 14:49:50 +0200743 }
744
Willy Tarreaubaaee002006-06-26 02:48:02 +0200745 /* if this server remaps proxied ports, we'll use
746 * the port the client connected to with an offset. */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200747 if ((objt_server(s->target)->state & SRV_MAPPORTS) && cli_conn) {
David du Colombier6f5ccb12011-03-10 22:26:24 +0100748 int base_port;
749
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200750 conn_get_to_addr(cli_conn);
David du Colombier6f5ccb12011-03-10 22:26:24 +0100751
752 /* First, retrieve the port from the incoming connection */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200753 base_port = get_host_port(&cli_conn->addr.to);
David du Colombier6f5ccb12011-03-10 22:26:24 +0100754
755 /* Second, assign the outgoing connection's port */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200756 base_port += get_host_port(&srv_conn->addr.to);
757 set_host_port(&srv_conn->addr.to, base_port);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200758 }
759 }
Willy Tarreau1620ec32011-08-06 17:05:02 +0200760 else if (s->be->options & PR_O_DISPATCH) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200761 /* connect to the defined dispatch addr */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200762 srv_conn->addr.to = s->be->dispatch_addr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200763 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200764 else if ((s->be->options & PR_O_TRANSP) && cli_conn) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200765 /* in transparent mode, use the original dest addr if no dispatch specified */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200766 conn_get_to_addr(cli_conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200767
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200768 if (cli_conn->addr.to.ss_family == AF_INET || cli_conn->addr.to.ss_family == AF_INET6)
769 srv_conn->addr.to = cli_conn->addr.to;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200770 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100771 else if (s->be->options & PR_O_HTTP_PROXY) {
772 /* If HTTP PROXY option is set, then server is already assigned
773 * during incoming client request parsing. */
774 }
Willy Tarreau1a1158b2007-01-20 11:07:46 +0100775 else {
776 /* no server and no LB algorithm ! */
777 return SRV_STATUS_INTERNAL;
778 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200779
780 s->flags |= SN_ADDR_SET;
781 return SRV_STATUS_OK;
782}
783
784
785/* This function assigns a server to session <s> if required, and can add the
786 * connection to either the assigned server's queue or to the proxy's queue.
Willy Tarreau7c669d72008-06-20 15:04:11 +0200787 * If ->srv_conn is set, the session is first released from the server.
788 * It may also be called with SN_DIRECT and/or SN_ASSIGNED though. It will
789 * be called before any connection and after any retry or redispatch occurs.
790 *
791 * It is not allowed to call this function with a session in a queue.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200792 *
793 * Returns :
794 *
795 * SRV_STATUS_OK if everything is OK.
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100796 * SRV_STATUS_NOSRV if no server is available. objt_server(s->target) = NULL.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200797 * SRV_STATUS_QUEUED if the connection has been queued.
798 * SRV_STATUS_FULL if the server(s) is/are saturated and the
Willy Tarreau827aee92011-03-10 16:55:02 +0100799 * connection could not be queued at the server's,
Willy Tarreau7c669d72008-06-20 15:04:11 +0200800 * which may be NULL if we queue on the backend.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200801 * SRV_STATUS_INTERNAL for other unrecoverable errors.
802 *
803 */
804int assign_server_and_queue(struct session *s)
805{
806 struct pendconn *p;
Willy Tarreau827aee92011-03-10 16:55:02 +0100807 struct server *srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200808 int err;
809
810 if (s->pend_pos)
811 return SRV_STATUS_INTERNAL;
812
Willy Tarreau7c669d72008-06-20 15:04:11 +0200813 err = SRV_STATUS_OK;
814 if (!(s->flags & SN_ASSIGNED)) {
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100815 struct server *prev_srv = objt_server(s->target);
Willy Tarreau3d80d912011-03-10 11:42:13 +0100816
Willy Tarreau7c669d72008-06-20 15:04:11 +0200817 err = assign_server(s);
Willy Tarreau3d80d912011-03-10 11:42:13 +0100818 if (prev_srv) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200819 /* This session was previously assigned to a server. We have to
820 * update the session's and the server's stats :
821 * - if the server changed :
822 * - set TX_CK_DOWN if txn.flags was TX_CK_VALID
823 * - set SN_REDISP if it was successfully redispatched
824 * - increment srv->redispatches and be->redispatches
825 * - if the server remained the same : update retries.
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100826 */
827
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100828 if (prev_srv != objt_server(s->target)) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200829 if ((s->txn.flags & TX_CK_MASK) == TX_CK_VALID) {
830 s->txn.flags &= ~TX_CK_MASK;
831 s->txn.flags |= TX_CK_DOWN;
832 }
833 s->flags |= SN_REDISP;
Willy Tarreau3d80d912011-03-10 11:42:13 +0100834 prev_srv->counters.redispatches++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100835 s->be->be_counters.redispatches++;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200836 } else {
Willy Tarreau3d80d912011-03-10 11:42:13 +0100837 prev_srv->counters.retries++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100838 s->be->be_counters.retries++;
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100839 }
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100840 }
841 }
842
Willy Tarreaubaaee002006-06-26 02:48:02 +0200843 switch (err) {
844 case SRV_STATUS_OK:
Willy Tarreau7c669d72008-06-20 15:04:11 +0200845 /* we have SN_ASSIGNED set */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100846 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +0100847 if (!srv)
Willy Tarreau7c669d72008-06-20 15:04:11 +0200848 return SRV_STATUS_OK; /* dispatch or proxy mode */
849
850 /* If we already have a connection slot, no need to check any queue */
Willy Tarreau827aee92011-03-10 16:55:02 +0100851 if (s->srv_conn == srv)
Willy Tarreau7c669d72008-06-20 15:04:11 +0200852 return SRV_STATUS_OK;
853
854 /* OK, this session already has an assigned server, but no
855 * connection slot yet. Either it is a redispatch, or it was
856 * assigned from persistence information (direct mode).
857 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100858 if ((s->flags & SN_REDIRECTABLE) && srv->rdr_len) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200859 /* server scheduled for redirection, and already assigned. We
860 * don't want to go further nor check the queue.
Willy Tarreau21d2af32008-02-14 20:25:24 +0100861 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100862 sess_change_server(s, srv); /* not really needed in fact */
Willy Tarreau21d2af32008-02-14 20:25:24 +0100863 return SRV_STATUS_OK;
864 }
865
Willy Tarreau7c669d72008-06-20 15:04:11 +0200866 /* We might have to queue this session if the assigned server is full.
867 * We know we have to queue it into the server's queue, so if a maxqueue
868 * is set on the server, we must also check that the server's queue is
869 * not full, in which case we have to return FULL.
870 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100871 if (srv->maxconn &&
872 (srv->nbpend || srv->served >= srv_dynamic_maxconn(srv))) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200873
Willy Tarreau827aee92011-03-10 16:55:02 +0100874 if (srv->maxqueue > 0 && srv->nbpend >= srv->maxqueue)
Willy Tarreau7c669d72008-06-20 15:04:11 +0200875 return SRV_STATUS_FULL;
876
Willy Tarreaubaaee002006-06-26 02:48:02 +0200877 p = pendconn_add(s);
878 if (p)
879 return SRV_STATUS_QUEUED;
880 else
Willy Tarreau7c669d72008-06-20 15:04:11 +0200881 return SRV_STATUS_INTERNAL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200882 }
Willy Tarreau7c669d72008-06-20 15:04:11 +0200883
884 /* OK, we can use this server. Let's reserve our place */
Willy Tarreau827aee92011-03-10 16:55:02 +0100885 sess_change_server(s, srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200886 return SRV_STATUS_OK;
887
888 case SRV_STATUS_FULL:
889 /* queue this session into the proxy's queue */
890 p = pendconn_add(s);
891 if (p)
892 return SRV_STATUS_QUEUED;
893 else
Willy Tarreau7c669d72008-06-20 15:04:11 +0200894 return SRV_STATUS_INTERNAL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200895
896 case SRV_STATUS_NOSRV:
Willy Tarreau7c669d72008-06-20 15:04:11 +0200897 return err;
898
Willy Tarreaubaaee002006-06-26 02:48:02 +0200899 case SRV_STATUS_INTERNAL:
900 return err;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200901
Willy Tarreaubaaee002006-06-26 02:48:02 +0200902 default:
903 return SRV_STATUS_INTERNAL;
904 }
Willy Tarreau5b6995c2008-01-13 16:31:17 +0100905}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200906
Willy Tarreaub1d67742010-03-29 19:36:59 +0200907/* If an explicit source binding is specified on the server and/or backend, and
908 * this source makes use of the transparent proxy, then it is extracted now and
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200909 * assigned to the session's pending connection. This function assumes that an
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200910 * outgoing connection has already been assigned to s->req->cons->end.
Willy Tarreaub1d67742010-03-29 19:36:59 +0200911 */
912static void assign_tproxy_address(struct session *s)
913{
Pieter Baauwd551fb52013-05-08 22:49:23 +0200914#if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100915 struct server *srv = objt_server(s->target);
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100916 struct conn_src *src;
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200917 struct connection *cli_conn;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200918 struct connection *srv_conn = objt_conn(s->req->cons->end);
Willy Tarreau827aee92011-03-10 16:55:02 +0100919
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100920 if (srv && srv->conn_src.opts & CO_SRC_BIND)
921 src = &srv->conn_src;
922 else if (s->be->conn_src.opts & CO_SRC_BIND)
923 src = &s->be->conn_src;
924 else
925 return;
Willy Tarreau294c4732011-12-16 21:35:50 +0100926
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100927 switch (src->opts & CO_SRC_TPROXY_MASK) {
928 case CO_SRC_TPROXY_ADDR:
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200929 srv_conn->addr.from = src->tproxy_addr;
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100930 break;
931 case CO_SRC_TPROXY_CLI:
932 case CO_SRC_TPROXY_CIP:
933 /* FIXME: what can we do if the client connects in IPv6 or unix socket ? */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200934 cli_conn = objt_conn(s->req->prod->end);
935 if (cli_conn)
936 srv_conn->addr.from = cli_conn->addr.from;
937 else
938 memset(&srv_conn->addr.from, 0, sizeof(srv_conn->addr.from));
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100939 break;
940 case CO_SRC_TPROXY_DYN:
941 if (src->bind_hdr_occ) {
942 char *vptr;
943 int vlen;
944 int rewind;
Willy Tarreau294c4732011-12-16 21:35:50 +0100945
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100946 /* bind to the IP in a header */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200947 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_family = AF_INET;
948 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_port = 0;
949 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_addr.s_addr = 0;
Willy Tarreau294c4732011-12-16 21:35:50 +0100950
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100951 b_rew(s->req->buf, rewind = s->req->buf->o);
952 if (http_get_hdr(&s->txn.req, src->bind_hdr_name, src->bind_hdr_len,
953 &s->txn.hdr_idx, src->bind_hdr_occ, NULL, &vptr, &vlen)) {
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200954 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_addr.s_addr =
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100955 htonl(inetaddr_host_lim(vptr, vptr + vlen));
Willy Tarreaubce70882009-09-07 11:51:47 +0200956 }
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100957 b_adv(s->req->buf, rewind);
Willy Tarreaub1d67742010-03-29 19:36:59 +0200958 }
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100959 break;
960 default:
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200961 memset(&srv_conn->addr.from, 0, sizeof(srv_conn->addr.from));
Willy Tarreaub1d67742010-03-29 19:36:59 +0200962 }
963#endif
964}
965
966
Willy Tarreaubaaee002006-06-26 02:48:02 +0200967/*
968 * This function initiates a connection to the server assigned to this session
Willy Tarreau6471afb2011-09-23 10:54:59 +0200969 * (s->target, s->req->cons->addr.to). It will assign a server if none
Willy Tarreau664beb82011-03-10 11:38:29 +0100970 * is assigned yet.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200971 * It can return one of :
972 * - SN_ERR_NONE if everything's OK
973 * - SN_ERR_SRVTO if there are no more servers
974 * - SN_ERR_SRVCL if the connection was refused by the server
975 * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
976 * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
977 * - SN_ERR_INTERNAL for any other purely internal errors
978 * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200979 * The server-facing stream interface is expected to hold a pre-allocated connection
980 * in s->req->cons->conn.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200981 */
982int connect_server(struct session *s)
983{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200984 struct connection *cli_conn;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200985 struct connection *srv_conn = si_alloc_conn(s->req->cons);
Willy Tarreau827aee92011-03-10 16:55:02 +0100986 struct server *srv;
Willy Tarreau9650f372009-08-16 14:02:45 +0200987 int err;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200988
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200989 if (!srv_conn)
990 return SN_ERR_RESOURCE;
991
Willy Tarreaubaaee002006-06-26 02:48:02 +0200992 if (!(s->flags & SN_ADDR_SET)) {
993 err = assign_server_address(s);
994 if (err != SRV_STATUS_OK)
995 return SN_ERR_INTERNAL;
996 }
997
Willy Tarreau7b7a8e92011-03-27 19:53:06 +0200998 /* the target was only on the session, assign it to the SI now */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200999 srv_conn->target = s->target;
Willy Tarreaud88edf22009-06-14 15:48:17 +02001000
Willy Tarreau26d8c592012-05-07 18:12:14 +02001001 /* set the correct protocol on the output stream interface */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001002 if (objt_server(s->target)) {
Willy Tarreau2a6e8802013-10-24 15:50:53 +02001003 conn_prepare(srv_conn, objt_server(s->target)->proto, objt_server(s->target)->xprt);
Willy Tarreaud02394b2012-05-11 18:32:18 +02001004 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001005 else if (obj_type(s->target) == OBJ_TYPE_PROXY) {
Willy Tarreau75bf2c92012-08-20 17:01:35 +02001006 /* proxies exclusively run on raw_sock right now */
Willy Tarreau2a6e8802013-10-24 15:50:53 +02001007 conn_prepare(srv_conn, protocol_by_family(srv_conn->addr.to.ss_family), &raw_sock);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001008 if (!objt_conn(s->req->cons->end) || !objt_conn(s->req->cons->end)->ctrl)
Willy Tarreau26d8c592012-05-07 18:12:14 +02001009 return SN_ERR_INTERNAL;
1010 }
Willy Tarreaud02394b2012-05-11 18:32:18 +02001011 else
1012 return SN_ERR_INTERNAL; /* how did we get there ? */
1013
Willy Tarreau2a6e8802013-10-24 15:50:53 +02001014 si_attach_conn(s->req->cons, srv_conn);
1015
Willy Tarreaud02394b2012-05-11 18:32:18 +02001016 /* process the case where the server requires the PROXY protocol to be sent */
Willy Tarreaub8020ce2013-10-24 21:10:08 +02001017 srv_conn->send_proxy_ofs = 0;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001018 if (objt_server(s->target) && (objt_server(s->target)->state & SRV_SEND_PROXY)) {
Willy Tarreaub8020ce2013-10-24 21:10:08 +02001019 srv_conn->send_proxy_ofs = 1; /* must compute size */
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001020 cli_conn = objt_conn(s->req->prod->end);
1021 if (cli_conn)
1022 conn_get_to_addr(cli_conn);
Willy Tarreaud02394b2012-05-11 18:32:18 +02001023 }
Willy Tarreau26d8c592012-05-07 18:12:14 +02001024
Willy Tarreaub1d67742010-03-29 19:36:59 +02001025 assign_tproxy_address(s);
1026
William Lallemandb7ff6a32012-03-02 14:35:21 +01001027 /* flag for logging source ip/port */
1028 if (s->fe->options2 & PR_O2_SRC_ADDR)
1029 s->req->cons->flags |= SI_FL_SRC_ADDR;
1030
Willy Tarreau14f8e862012-08-30 22:23:13 +02001031 /* disable lingering */
1032 if (s->be->options & PR_O_TCP_NOLING)
1033 s->req->cons->flags |= SI_FL_NOLINGER;
1034
Willy Tarreau73b013b2012-05-21 16:31:45 +02001035 err = si_connect(s->req->cons);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001036
Willy Tarreau9650f372009-08-16 14:02:45 +02001037 if (err != SN_ERR_NONE)
1038 return err;
Willy Tarreau788e2842008-08-26 13:25:39 +02001039
Willy Tarreau14f8e862012-08-30 22:23:13 +02001040 /* set connect timeout */
1041 s->req->cons->exp = tick_add_ifset(now_ms, s->be->timeout.connect);
1042
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001043 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001044 if (srv) {
Willy Tarreau1e62de62008-11-11 20:20:02 +01001045 s->flags |= SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +01001046 srv->cur_sess++;
1047 if (srv->cur_sess > srv->counters.cur_sess_max)
1048 srv->counters.cur_sess_max = srv->cur_sess;
Willy Tarreau51406232008-03-10 22:04:20 +01001049 if (s->be->lbprm.server_take_conn)
Willy Tarreau827aee92011-03-10 16:55:02 +01001050 s->be->lbprm.server_take_conn(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001051 }
1052
Willy Tarreaubaaee002006-06-26 02:48:02 +02001053 return SN_ERR_NONE; /* connection is OK */
1054}
1055
1056
Willy Tarreaubaaee002006-06-26 02:48:02 +02001057/* This function performs the "redispatch" part of a connection attempt. It
1058 * will assign a server if required, queue the connection if required, and
1059 * handle errors that might arise at this level. It can change the server
1060 * state. It will return 1 if it encounters an error, switches the server
1061 * state, or has to queue a connection. Otherwise, it will return 0 indicating
1062 * that the connection is ready to use.
1063 */
1064
1065int srv_redispatch_connect(struct session *t)
1066{
Willy Tarreau827aee92011-03-10 16:55:02 +01001067 struct server *srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001068 int conn_err;
1069
1070 /* We know that we don't have any connection pending, so we will
1071 * try to get a new one, and wait in this state if it's queued
1072 */
Willy Tarreau7c669d72008-06-20 15:04:11 +02001073 redispatch:
Willy Tarreaubaaee002006-06-26 02:48:02 +02001074 conn_err = assign_server_and_queue(t);
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001075 srv = objt_server(t->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001076
Willy Tarreaubaaee002006-06-26 02:48:02 +02001077 switch (conn_err) {
1078 case SRV_STATUS_OK:
1079 break;
1080
Willy Tarreau7c669d72008-06-20 15:04:11 +02001081 case SRV_STATUS_FULL:
1082 /* The server has reached its maxqueue limit. Either PR_O_REDISP is set
1083 * and we can redispatch to another server, or it is not and we return
1084 * 503. This only makes sense in DIRECT mode however, because normal LB
1085 * algorithms would never select such a server, and hash algorithms
Willy Tarreau827aee92011-03-10 16:55:02 +01001086 * would bring us on the same server again. Note that t->target is set
1087 * in this case.
Willy Tarreau7c669d72008-06-20 15:04:11 +02001088 */
Willy Tarreau4de91492010-01-22 19:10:05 +01001089 if (((t->flags & (SN_DIRECT|SN_FORCE_PRST)) == SN_DIRECT) &&
1090 (t->be->options & PR_O_REDISP)) {
Willy Tarreau7c669d72008-06-20 15:04:11 +02001091 t->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Willy Tarreau7c669d72008-06-20 15:04:11 +02001092 goto redispatch;
1093 }
1094
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001095 if (!t->req->cons->err_type) {
1096 t->req->cons->err_type = SI_ET_QUEUE_ERR;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001097 }
Willy Tarreau7c669d72008-06-20 15:04:11 +02001098
Willy Tarreau827aee92011-03-10 16:55:02 +01001099 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001100 t->be->be_counters.failed_conns++;
Willy Tarreau7c669d72008-06-20 15:04:11 +02001101 return 1;
1102
Willy Tarreaubaaee002006-06-26 02:48:02 +02001103 case SRV_STATUS_NOSRV:
Willy Tarreau827aee92011-03-10 16:55:02 +01001104 /* note: it is guaranteed that srv == NULL here */
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001105 if (!t->req->cons->err_type) {
1106 t->req->cons->err_type = SI_ET_CONN_ERR;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001107 }
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +01001108
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001109 t->be->be_counters.failed_conns++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001110 return 1;
1111
1112 case SRV_STATUS_QUEUED:
Willy Tarreau35374672008-09-03 18:11:02 +02001113 t->req->cons->exp = tick_add_ifset(now_ms, t->be->timeout.queue);
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001114 t->req->cons->state = SI_ST_QUE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001115 /* do nothing else and do not wake any other session up */
1116 return 1;
1117
Willy Tarreaubaaee002006-06-26 02:48:02 +02001118 case SRV_STATUS_INTERNAL:
1119 default:
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001120 if (!t->req->cons->err_type) {
1121 t->req->cons->err_type = SI_ET_CONN_OTHER;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001122 }
1123
Willy Tarreau827aee92011-03-10 16:55:02 +01001124 if (srv)
1125 srv_inc_sess_ctr(srv);
1126 if (srv)
1127 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001128 t->be->be_counters.failed_conns++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001129
1130 /* release other sessions waiting for this server */
Willy Tarreau827aee92011-03-10 16:55:02 +01001131 if (may_dequeue_tasks(srv, t->be))
1132 process_srv_queue(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001133 return 1;
1134 }
1135 /* if we get here, it's because we got SRV_STATUS_OK, which also
1136 * means that the connection has not been queued.
1137 */
1138 return 0;
1139}
1140
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001141/* Apply RDP cookie persistence to the current session. For this, the function
1142 * tries to extract an RDP cookie from the request buffer, and look for the
1143 * matching server in the list. If the server is found, it is assigned to the
1144 * session. This always returns 1, and the analyser removes itself from the
1145 * list. Nothing is performed if a server was already assigned.
1146 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001147int tcp_persist_rdp_cookie(struct session *s, struct channel *req, int an_bit)
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001148{
1149 struct proxy *px = s->be;
1150 int ret;
Willy Tarreau37406352012-04-23 16:16:37 +02001151 struct sample smp;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001152 struct server *srv = px->srv;
1153 struct sockaddr_in addr;
1154 char *p;
1155
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001156 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001157 now_ms, __FUNCTION__,
1158 s,
1159 req,
1160 req->rex, req->wex,
1161 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001162 req->buf->i,
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001163 req->analysers);
1164
1165 if (s->flags & SN_ASSIGNED)
1166 goto no_cookie;
1167
Willy Tarreau37406352012-04-23 16:16:37 +02001168 memset(&smp, 0, sizeof(smp));
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001169
Willy Tarreaucadd8c92013-07-22 18:09:52 +02001170 ret = fetch_rdp_cookie_name(s, &smp, s->be->rdp_cookie_name, s->be->rdp_cookie_len);
Willy Tarreauf853c462012-04-23 18:53:56 +02001171 if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || smp.data.str.len == 0)
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001172 goto no_cookie;
1173
1174 memset(&addr, 0, sizeof(addr));
1175 addr.sin_family = AF_INET;
1176
Willy Tarreau664092c2011-12-16 19:11:42 +01001177 /* Considering an rdp cookie detected using acl, str ended with <cr><lf> and should return */
Willy Tarreauf853c462012-04-23 18:53:56 +02001178 addr.sin_addr.s_addr = strtoul(smp.data.str.str, &p, 10);
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001179 if (*p != '.')
1180 goto no_cookie;
1181 p++;
1182 addr.sin_port = (unsigned short)strtoul(p, &p, 10);
1183 if (*p != '.')
1184 goto no_cookie;
1185
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001186 s->target = NULL;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001187 while (srv) {
1188 if (memcmp(&addr, &(srv->addr), sizeof(addr)) == 0) {
1189 if ((srv->state & SRV_RUNNING) || (px->options & PR_O_PERSIST)) {
1190 /* we found the server and it is usable */
1191 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001192 s->target = &srv->obj_type;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001193 break;
1194 }
1195 }
1196 srv = srv->next;
1197 }
1198
1199no_cookie:
1200 req->analysers &= ~an_bit;
1201 req->analyse_exp = TICK_ETERNITY;
1202 return 1;
1203}
1204
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001205int be_downtime(struct proxy *px) {
Willy Tarreaub625a082007-11-26 01:15:43 +01001206 if (px->lbprm.tot_weight && px->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001207 return px->down_time;
1208
1209 return now.tv_sec - px->last_change + px->down_time;
1210}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001211
Krzysztof Piotr Oledzki15514c22010-01-04 16:03:09 +01001212/*
1213 * This function returns a string containing the balancing
1214 * mode of the proxy in a format suitable for stats.
1215 */
1216
1217const char *backend_lb_algo_str(int algo) {
1218
1219 if (algo == BE_LB_ALGO_RR)
1220 return "roundrobin";
1221 else if (algo == BE_LB_ALGO_SRR)
1222 return "static-rr";
Willy Tarreauf09c6602012-02-13 17:12:08 +01001223 else if (algo == BE_LB_ALGO_FAS)
1224 return "first";
Krzysztof Piotr Oledzki15514c22010-01-04 16:03:09 +01001225 else if (algo == BE_LB_ALGO_LC)
1226 return "leastconn";
1227 else if (algo == BE_LB_ALGO_SH)
1228 return "source";
1229 else if (algo == BE_LB_ALGO_UH)
1230 return "uri";
1231 else if (algo == BE_LB_ALGO_PH)
1232 return "url_param";
1233 else if (algo == BE_LB_ALGO_HH)
1234 return "hdr";
1235 else if (algo == BE_LB_ALGO_RCH)
1236 return "rdp-cookie";
1237 else
1238 return NULL;
1239}
1240
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001241/* This function parses a "balance" statement in a backend section describing
1242 * <curproxy>. It returns -1 if there is any error, otherwise zero. If it
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001243 * returns -1, it will write an error message into the <err> buffer which will
1244 * automatically be allocated and must be passed as NULL. The trailing '\n'
1245 * will not be written. The function must be called with <args> pointing to the
1246 * first word after "balance".
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001247 */
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001248int backend_parse_balance(const char **args, char **err, struct proxy *curproxy)
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001249{
1250 if (!*(args[0])) {
1251 /* if no option is set, use round-robin by default */
Willy Tarreau31682232007-11-29 15:38:04 +01001252 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1253 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001254 return 0;
1255 }
1256
1257 if (!strcmp(args[0], "roundrobin")) {
Willy Tarreau31682232007-11-29 15:38:04 +01001258 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1259 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001260 }
Willy Tarreau9757a382009-10-03 12:56:50 +02001261 else if (!strcmp(args[0], "static-rr")) {
1262 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1263 curproxy->lbprm.algo |= BE_LB_ALGO_SRR;
1264 }
Willy Tarreauf09c6602012-02-13 17:12:08 +01001265 else if (!strcmp(args[0], "first")) {
1266 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1267 curproxy->lbprm.algo |= BE_LB_ALGO_FAS;
1268 }
Willy Tarreau51406232008-03-10 22:04:20 +01001269 else if (!strcmp(args[0], "leastconn")) {
1270 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1271 curproxy->lbprm.algo |= BE_LB_ALGO_LC;
1272 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001273 else if (!strcmp(args[0], "source")) {
Willy Tarreau31682232007-11-29 15:38:04 +01001274 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1275 curproxy->lbprm.algo |= BE_LB_ALGO_SH;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001276 }
1277 else if (!strcmp(args[0], "uri")) {
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001278 int arg = 1;
1279
Willy Tarreau31682232007-11-29 15:38:04 +01001280 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1281 curproxy->lbprm.algo |= BE_LB_ALGO_UH;
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001282
Oskar Stolc8dc41842012-05-19 10:19:54 +01001283 curproxy->uri_whole = 0;
1284
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001285 while (*args[arg]) {
1286 if (!strcmp(args[arg], "len")) {
1287 if (!*args[arg+1] || (atoi(args[arg+1]) <= 0)) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001288 memprintf(err, "%s : '%s' expects a positive integer (got '%s').", args[0], args[arg], args[arg+1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001289 return -1;
1290 }
1291 curproxy->uri_len_limit = atoi(args[arg+1]);
1292 arg += 2;
1293 }
1294 else if (!strcmp(args[arg], "depth")) {
1295 if (!*args[arg+1] || (atoi(args[arg+1]) <= 0)) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001296 memprintf(err, "%s : '%s' expects a positive integer (got '%s').", args[0], args[arg], args[arg+1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001297 return -1;
1298 }
1299 /* hint: we store the position of the ending '/' (depth+1) so
1300 * that we avoid a comparison while computing the hash.
1301 */
1302 curproxy->uri_dirs_depth1 = atoi(args[arg+1]) + 1;
1303 arg += 2;
1304 }
Oskar Stolc8dc41842012-05-19 10:19:54 +01001305 else if (!strcmp(args[arg], "whole")) {
1306 curproxy->uri_whole = 1;
1307 arg += 1;
1308 }
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001309 else {
Oskar Stolc8dc41842012-05-19 10:19:54 +01001310 memprintf(err, "%s only accepts parameters 'len', 'depth', and 'whole' (got '%s').", args[0], args[arg]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001311 return -1;
1312 }
1313 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001314 }
Willy Tarreau01732802007-11-01 22:48:15 +01001315 else if (!strcmp(args[0], "url_param")) {
1316 if (!*args[1]) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001317 memprintf(err, "%s requires an URL parameter name.", args[0]);
Willy Tarreau01732802007-11-01 22:48:15 +01001318 return -1;
1319 }
Willy Tarreau31682232007-11-29 15:38:04 +01001320 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1321 curproxy->lbprm.algo |= BE_LB_ALGO_PH;
Willy Tarreaua534fea2008-08-03 12:19:50 +02001322
1323 free(curproxy->url_param_name);
Willy Tarreau01732802007-11-01 22:48:15 +01001324 curproxy->url_param_name = strdup(args[1]);
Willy Tarreaua534fea2008-08-03 12:19:50 +02001325 curproxy->url_param_len = strlen(args[1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001326 if (*args[2]) {
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001327 if (strcmp(args[2], "check_post")) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001328 memprintf(err, "%s only accepts 'check_post' modifier (got '%s').", args[0], args[2]);
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001329 return -1;
1330 }
1331 if (*args[3]) {
1332 /* TODO: maybe issue a warning if there is no value, no digits or too long */
1333 curproxy->url_param_post_limit = str2ui(args[3]);
1334 }
1335 /* if no limit, or faul value in args[3], then default to a moderate wordlen */
1336 if (!curproxy->url_param_post_limit)
1337 curproxy->url_param_post_limit = 48;
1338 else if ( curproxy->url_param_post_limit < 3 )
1339 curproxy->url_param_post_limit = 3; /* minimum example: S=3 or \r\nS=6& */
1340 }
Benoitaffb4812009-03-25 13:02:10 +01001341 }
1342 else if (!strncmp(args[0], "hdr(", 4)) {
1343 const char *beg, *end;
1344
1345 beg = args[0] + 4;
1346 end = strchr(beg, ')');
1347
1348 if (!end || end == beg) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001349 memprintf(err, "hdr requires an http header field name.");
Benoitaffb4812009-03-25 13:02:10 +01001350 return -1;
1351 }
1352
1353 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1354 curproxy->lbprm.algo |= BE_LB_ALGO_HH;
1355
1356 free(curproxy->hh_name);
1357 curproxy->hh_len = end - beg;
1358 curproxy->hh_name = my_strndup(beg, end - beg);
1359 curproxy->hh_match_domain = 0;
1360
1361 if (*args[1]) {
1362 if (strcmp(args[1], "use_domain_only")) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001363 memprintf(err, "%s only accepts 'use_domain_only' modifier (got '%s').", args[0], args[1]);
Benoitaffb4812009-03-25 13:02:10 +01001364 return -1;
1365 }
1366 curproxy->hh_match_domain = 1;
1367 }
Emeric Brun736aa232009-06-30 17:56:00 +02001368 }
1369 else if (!strncmp(args[0], "rdp-cookie", 10)) {
1370 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1371 curproxy->lbprm.algo |= BE_LB_ALGO_RCH;
1372
1373 if ( *(args[0] + 10 ) == '(' ) { /* cookie name */
1374 const char *beg, *end;
1375
1376 beg = args[0] + 11;
1377 end = strchr(beg, ')');
1378
1379 if (!end || end == beg) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001380 memprintf(err, "rdp-cookie : missing cookie name.");
Emeric Brun736aa232009-06-30 17:56:00 +02001381 return -1;
1382 }
1383
1384 free(curproxy->hh_name);
1385 curproxy->hh_name = my_strndup(beg, end - beg);
1386 curproxy->hh_len = end - beg;
1387 }
1388 else if ( *(args[0] + 10 ) == '\0' ) { /* default cookie name 'mstshash' */
1389 free(curproxy->hh_name);
1390 curproxy->hh_name = strdup("mstshash");
1391 curproxy->hh_len = strlen(curproxy->hh_name);
1392 }
1393 else { /* syntax */
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001394 memprintf(err, "rdp-cookie : missing cookie name.");
Emeric Brun736aa232009-06-30 17:56:00 +02001395 return -1;
1396 }
Willy Tarreau01732802007-11-01 22:48:15 +01001397 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001398 else {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001399 memprintf(err, "only supports 'roundrobin', 'static-rr', 'leastconn', 'source', 'uri', 'url_param', 'hdr(name)' and 'rdp-cookie(name)' options.");
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001400 return -1;
1401 }
1402 return 0;
1403}
1404
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001405
1406/************************************************************************/
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001407/* All supported sample and ACL keywords must be declared here. */
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001408/************************************************************************/
1409
Willy Tarreau34db1082012-04-19 17:16:54 +02001410/* set temp integer to the number of enabled servers on the proxy.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001411 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001412 * undefined behaviour.
1413 */
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001414static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001415smp_fetch_nbsrv(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001416 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001417{
Willy Tarreau37406352012-04-23 16:16:37 +02001418 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001419 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001420 px = args->data.prx;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001421
1422 if (px->srv_act)
Willy Tarreauf853c462012-04-23 18:53:56 +02001423 smp->data.uint = px->srv_act;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001424 else if (px->lbprm.fbck)
Willy Tarreauf853c462012-04-23 18:53:56 +02001425 smp->data.uint = 1;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001426 else
Willy Tarreauf853c462012-04-23 18:53:56 +02001427 smp->data.uint = px->srv_bck;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001428
1429 return 1;
1430}
1431
Willy Tarreau37406352012-04-23 16:16:37 +02001432/* report in smp->flags a success or failure depending on the designated
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001433 * server's state. There is no match function involved since there's no pattern.
Willy Tarreau34db1082012-04-19 17:16:54 +02001434 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1435 * undefined behaviour.
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001436 */
1437static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001438smp_fetch_srv_is_up(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001439 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001440{
Willy Tarreau24e32d82012-04-23 23:55:44 +02001441 struct server *srv = args->data.srv;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001442
Willy Tarreau37406352012-04-23 16:16:37 +02001443 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001444 smp->type = SMP_T_BOOL;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001445 if (!(srv->state & SRV_MAINTAIN) &&
Willy Tarreauff5ae352013-12-11 20:36:34 +01001446 (!(srv->check.state & CHK_ST_CONFIGURED) || (srv->state & SRV_RUNNING)))
Willy Tarreau197e10a2012-04-23 19:18:42 +02001447 smp->data.uint = 1;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001448 else
Willy Tarreau197e10a2012-04-23 19:18:42 +02001449 smp->data.uint = 0;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001450 return 1;
1451}
1452
Willy Tarreau34db1082012-04-19 17:16:54 +02001453/* set temp integer to the number of enabled servers on the proxy.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001454 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001455 * undefined behaviour.
1456 */
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001457static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001458smp_fetch_connslots(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001459 const struct arg *args, struct sample *smp, const char *kw)
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001460{
1461 struct server *iterator;
Willy Tarreaud28c3532012-04-19 19:28:33 +02001462
Willy Tarreau37406352012-04-23 16:16:37 +02001463 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001464 smp->type = SMP_T_UINT;
1465 smp->data.uint = 0;
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001466
Willy Tarreau24e32d82012-04-23 23:55:44 +02001467 for (iterator = args->data.prx->srv; iterator; iterator = iterator->next) {
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001468 if ((iterator->state & SRV_RUNNING) == 0)
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001469 continue;
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001470
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001471 if (iterator->maxconn == 0 || iterator->maxqueue == 0) {
Willy Tarreaua5e37562011-12-16 17:06:15 +01001472 /* configuration is stupid */
Willy Tarreauf853c462012-04-23 18:53:56 +02001473 smp->data.uint = -1; /* FIXME: stupid value! */
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001474 return 1;
1475 }
1476
Willy Tarreauf853c462012-04-23 18:53:56 +02001477 smp->data.uint += (iterator->maxconn - iterator->cur_sess)
Willy Tarreau422aa072012-04-20 20:49:27 +02001478 + (iterator->maxqueue - iterator->nbpend);
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001479 }
1480
1481 return 1;
1482}
1483
Willy Tarreaua5e37562011-12-16 17:06:15 +01001484/* set temp integer to the id of the backend */
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001485static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001486smp_fetch_be_id(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001487 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau37406352012-04-23 16:16:37 +02001488{
Willy Tarreauf853c462012-04-23 18:53:56 +02001489 smp->flags = SMP_F_VOL_TXN;
1490 smp->type = SMP_T_UINT;
1491 smp->data.uint = l4->be->uuid;
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001492 return 1;
1493}
1494
Willy Tarreaua5e37562011-12-16 17:06:15 +01001495/* set temp integer to the id of the server */
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001496static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001497smp_fetch_srv_id(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001498 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau37406352012-04-23 16:16:37 +02001499{
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001500 if (!objt_server(l4->target))
Willy Tarreau17af4192011-02-23 14:27:06 +01001501 return 0;
1502
Willy Tarreauf853c462012-04-23 18:53:56 +02001503 smp->type = SMP_T_UINT;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001504 smp->data.uint = objt_server(l4->target)->puid;
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001505
1506 return 1;
1507}
1508
Willy Tarreau34db1082012-04-19 17:16:54 +02001509/* set temp integer to the number of connections per second reaching the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001510 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001511 * undefined behaviour.
1512 */
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001513static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001514smp_fetch_be_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001515 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001516{
Willy Tarreau37406352012-04-23 16:16:37 +02001517 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001518 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001519 smp->data.uint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001520 return 1;
1521}
1522
Willy Tarreau34db1082012-04-19 17:16:54 +02001523/* set temp integer to the number of concurrent connections on the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001524 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001525 * undefined behaviour.
1526 */
Willy Tarreaua36af912009-10-10 12:02:45 +02001527static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001528smp_fetch_be_conn(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001529 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001530{
Willy Tarreau37406352012-04-23 16:16:37 +02001531 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001532 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001533 smp->data.uint = args->data.prx->beconn;
Willy Tarreaua36af912009-10-10 12:02:45 +02001534 return 1;
1535}
1536
Willy Tarreau34db1082012-04-19 17:16:54 +02001537/* set temp integer to the total number of queued connections on the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001538 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001539 * undefined behaviour.
1540 */
Willy Tarreaua36af912009-10-10 12:02:45 +02001541static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001542smp_fetch_queue_size(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001543 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001544{
Willy Tarreau37406352012-04-23 16:16:37 +02001545 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001546 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001547 smp->data.uint = args->data.prx->totpend;
Willy Tarreaua36af912009-10-10 12:02:45 +02001548 return 1;
1549}
1550
Willy Tarreaua5e37562011-12-16 17:06:15 +01001551/* set temp integer to the total number of queued connections on the backend divided
Willy Tarreaua36af912009-10-10 12:02:45 +02001552 * by the number of running servers and rounded up. If there is no running
1553 * server, we return twice the total, just as if we had half a running server.
1554 * This is more or less correct anyway, since we expect the last server to come
1555 * back soon.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001556 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001557 * undefined behaviour.
Willy Tarreaua36af912009-10-10 12:02:45 +02001558 */
1559static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001560smp_fetch_avg_queue_size(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001561 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001562{
1563 int nbsrv;
1564
Willy Tarreau37406352012-04-23 16:16:37 +02001565 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001566 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001567 px = args->data.prx;
Willy Tarreaua36af912009-10-10 12:02:45 +02001568
1569 if (px->srv_act)
1570 nbsrv = px->srv_act;
1571 else if (px->lbprm.fbck)
1572 nbsrv = 1;
1573 else
1574 nbsrv = px->srv_bck;
1575
1576 if (nbsrv > 0)
Willy Tarreauf853c462012-04-23 18:53:56 +02001577 smp->data.uint = (px->totpend + nbsrv - 1) / nbsrv;
Willy Tarreaua36af912009-10-10 12:02:45 +02001578 else
Willy Tarreauf853c462012-04-23 18:53:56 +02001579 smp->data.uint = px->totpend * 2;
Willy Tarreaua36af912009-10-10 12:02:45 +02001580
1581 return 1;
1582}
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001583
Willy Tarreau34db1082012-04-19 17:16:54 +02001584/* set temp integer to the number of concurrent connections on the server in the backend.
1585 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1586 * undefined behaviour.
1587 */
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001588static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001589smp_fetch_srv_conn(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001590 const struct arg *args, struct sample *smp, const char *kw)
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001591{
Willy Tarreauf853c462012-04-23 18:53:56 +02001592 smp->flags = SMP_F_VOL_TEST;
1593 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001594 smp->data.uint = args->data.srv->cur_sess;
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001595 return 1;
1596}
1597
Tait Clarridge7896d522012-12-05 21:39:31 -05001598/* set temp integer to the number of enabled servers on the proxy.
1599 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1600 * undefined behaviour.
1601 */
1602static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001603smp_fetch_srv_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001604 const struct arg *args, struct sample *smp, const char *kw)
Tait Clarridge7896d522012-12-05 21:39:31 -05001605{
1606 smp->flags = SMP_F_VOL_TEST;
1607 smp->type = SMP_T_UINT;
1608 smp->data.uint = read_freq_ctr(&args->data.srv->sess_per_sec);
1609 return 1;
1610}
1611
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001612
1613/* Note: must not be declared <const> as its list will be overwritten.
1614 * Please take care of keeping this list alphabetically sorted.
1615 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001616static struct sample_fetch_kw_list smp_kws = {ILH, {
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001617 { "avg_queue", smp_fetch_avg_queue_size, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1618 { "be_conn", smp_fetch_be_conn, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1619 { "be_id", smp_fetch_be_id, 0, NULL, SMP_T_UINT, SMP_USE_BKEND, },
1620 { "be_sess_rate", smp_fetch_be_sess_rate, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1621 { "connslots", smp_fetch_connslots, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1622 { "nbsrv", smp_fetch_nbsrv, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1623 { "queue", smp_fetch_queue_size, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1624 { "srv_conn", smp_fetch_srv_conn, ARG1(1,SRV), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1625 { "srv_id", smp_fetch_srv_id, 0, NULL, SMP_T_UINT, SMP_USE_SERVR, },
1626 { "srv_is_up", smp_fetch_srv_is_up, ARG1(1,SRV), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
1627 { "srv_sess_rate", smp_fetch_srv_sess_rate, ARG1(1,SRV), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1628 { /* END */ },
1629}};
1630
1631
Willy Tarreau61612d42012-04-19 18:42:05 +02001632/* Note: must not be declared <const> as its list will be overwritten.
1633 * Please take care of keeping this list alphabetically sorted.
1634 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001635static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001636 { /* END */ },
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001637}};
1638
1639
1640__attribute__((constructor))
1641static void __backend_init(void)
1642{
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001643 sample_register_fetches(&smp_kws);
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001644 acl_register_keywords(&acl_kws);
1645}
1646
Willy Tarreaubaaee002006-06-26 02:48:02 +02001647/*
1648 * Local variables:
1649 * c-indent-level: 8
1650 * c-basic-offset: 8
1651 * End:
1652 */