blob: 65cbcb6500fb68d588d437599ee14f6b265f912e [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 Tarreaub363a1f2013-10-01 10:45:07 +0200711 * The address is set on si->conn only. This connection is expected to be
712 * already allocated and initialized.
713 *
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);
718 struct connection *srv_conn = s->req->cons->conn;
719
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
910 * outgoing connection has already been allocated into s->req->cons->conn.
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;
918 struct connection *srv_conn = s->req->cons->conn;
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;
985 struct connection *srv_conn = s->req->cons->conn;
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
989 if (!(s->flags & SN_ADDR_SET)) {
990 err = assign_server_address(s);
991 if (err != SRV_STATUS_OK)
992 return SN_ERR_INTERNAL;
993 }
994
Willy Tarreau7b7a8e92011-03-27 19:53:06 +0200995 /* the target was only on the session, assign it to the SI now */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200996 srv_conn->target = s->target;
Willy Tarreaud88edf22009-06-14 15:48:17 +0200997
Willy Tarreau26d8c592012-05-07 18:12:14 +0200998 /* set the correct protocol on the output stream interface */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100999 if (objt_server(s->target)) {
1000 si_prepare_conn(s->req->cons, objt_server(s->target)->proto, objt_server(s->target)->xprt);
Willy Tarreaud02394b2012-05-11 18:32:18 +02001001 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001002 else if (obj_type(s->target) == OBJ_TYPE_PROXY) {
Willy Tarreau75bf2c92012-08-20 17:01:35 +02001003 /* proxies exclusively run on raw_sock right now */
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001004 si_prepare_conn(s->req->cons, protocol_by_family(srv_conn->addr.to.ss_family), &raw_sock);
1005 if (!objt_conn(s->req->cons->end) || !objt_conn(s->req->cons->end)->ctrl)
Willy Tarreau26d8c592012-05-07 18:12:14 +02001006 return SN_ERR_INTERNAL;
1007 }
Willy Tarreaud02394b2012-05-11 18:32:18 +02001008 else
1009 return SN_ERR_INTERNAL; /* how did we get there ? */
1010
1011 /* process the case where the server requires the PROXY protocol to be sent */
1012 s->req->cons->send_proxy_ofs = 0;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001013 if (objt_server(s->target) && (objt_server(s->target)->state & SRV_SEND_PROXY)) {
Willy Tarreaud02394b2012-05-11 18:32:18 +02001014 s->req->cons->send_proxy_ofs = 1; /* must compute size */
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001015 cli_conn = objt_conn(s->req->prod->end);
1016 if (cli_conn)
1017 conn_get_to_addr(cli_conn);
Willy Tarreaud02394b2012-05-11 18:32:18 +02001018 }
Willy Tarreau26d8c592012-05-07 18:12:14 +02001019
Willy Tarreaub1d67742010-03-29 19:36:59 +02001020 assign_tproxy_address(s);
1021
William Lallemandb7ff6a32012-03-02 14:35:21 +01001022 /* flag for logging source ip/port */
1023 if (s->fe->options2 & PR_O2_SRC_ADDR)
1024 s->req->cons->flags |= SI_FL_SRC_ADDR;
1025
Willy Tarreau14f8e862012-08-30 22:23:13 +02001026 /* disable lingering */
1027 if (s->be->options & PR_O_TCP_NOLING)
1028 s->req->cons->flags |= SI_FL_NOLINGER;
1029
Willy Tarreau73b013b2012-05-21 16:31:45 +02001030 err = si_connect(s->req->cons);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001031
Willy Tarreau9650f372009-08-16 14:02:45 +02001032 if (err != SN_ERR_NONE)
1033 return err;
Willy Tarreau788e2842008-08-26 13:25:39 +02001034
Willy Tarreau14f8e862012-08-30 22:23:13 +02001035 /* set connect timeout */
1036 s->req->cons->exp = tick_add_ifset(now_ms, s->be->timeout.connect);
1037
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001038 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001039 if (srv) {
Willy Tarreau1e62de62008-11-11 20:20:02 +01001040 s->flags |= SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +01001041 srv->cur_sess++;
1042 if (srv->cur_sess > srv->counters.cur_sess_max)
1043 srv->counters.cur_sess_max = srv->cur_sess;
Willy Tarreau51406232008-03-10 22:04:20 +01001044 if (s->be->lbprm.server_take_conn)
Willy Tarreau827aee92011-03-10 16:55:02 +01001045 s->be->lbprm.server_take_conn(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001046 }
1047
Willy Tarreaubaaee002006-06-26 02:48:02 +02001048 return SN_ERR_NONE; /* connection is OK */
1049}
1050
1051
Willy Tarreaubaaee002006-06-26 02:48:02 +02001052/* This function performs the "redispatch" part of a connection attempt. It
1053 * will assign a server if required, queue the connection if required, and
1054 * handle errors that might arise at this level. It can change the server
1055 * state. It will return 1 if it encounters an error, switches the server
1056 * state, or has to queue a connection. Otherwise, it will return 0 indicating
1057 * that the connection is ready to use.
1058 */
1059
1060int srv_redispatch_connect(struct session *t)
1061{
Willy Tarreau827aee92011-03-10 16:55:02 +01001062 struct server *srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001063 int conn_err;
1064
1065 /* We know that we don't have any connection pending, so we will
1066 * try to get a new one, and wait in this state if it's queued
1067 */
Willy Tarreau7c669d72008-06-20 15:04:11 +02001068 redispatch:
Willy Tarreaubaaee002006-06-26 02:48:02 +02001069 conn_err = assign_server_and_queue(t);
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001070 srv = objt_server(t->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001071
Willy Tarreaubaaee002006-06-26 02:48:02 +02001072 switch (conn_err) {
1073 case SRV_STATUS_OK:
1074 break;
1075
Willy Tarreau7c669d72008-06-20 15:04:11 +02001076 case SRV_STATUS_FULL:
1077 /* The server has reached its maxqueue limit. Either PR_O_REDISP is set
1078 * and we can redispatch to another server, or it is not and we return
1079 * 503. This only makes sense in DIRECT mode however, because normal LB
1080 * algorithms would never select such a server, and hash algorithms
Willy Tarreau827aee92011-03-10 16:55:02 +01001081 * would bring us on the same server again. Note that t->target is set
1082 * in this case.
Willy Tarreau7c669d72008-06-20 15:04:11 +02001083 */
Willy Tarreau4de91492010-01-22 19:10:05 +01001084 if (((t->flags & (SN_DIRECT|SN_FORCE_PRST)) == SN_DIRECT) &&
1085 (t->be->options & PR_O_REDISP)) {
Willy Tarreau7c669d72008-06-20 15:04:11 +02001086 t->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Willy Tarreau7c669d72008-06-20 15:04:11 +02001087 goto redispatch;
1088 }
1089
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001090 if (!t->req->cons->err_type) {
1091 t->req->cons->err_type = SI_ET_QUEUE_ERR;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001092 }
Willy Tarreau7c669d72008-06-20 15:04:11 +02001093
Willy Tarreau827aee92011-03-10 16:55:02 +01001094 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001095 t->be->be_counters.failed_conns++;
Willy Tarreau7c669d72008-06-20 15:04:11 +02001096 return 1;
1097
Willy Tarreaubaaee002006-06-26 02:48:02 +02001098 case SRV_STATUS_NOSRV:
Willy Tarreau827aee92011-03-10 16:55:02 +01001099 /* note: it is guaranteed that srv == NULL here */
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001100 if (!t->req->cons->err_type) {
1101 t->req->cons->err_type = SI_ET_CONN_ERR;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001102 }
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +01001103
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001104 t->be->be_counters.failed_conns++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001105 return 1;
1106
1107 case SRV_STATUS_QUEUED:
Willy Tarreau35374672008-09-03 18:11:02 +02001108 t->req->cons->exp = tick_add_ifset(now_ms, t->be->timeout.queue);
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001109 t->req->cons->state = SI_ST_QUE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001110 /* do nothing else and do not wake any other session up */
1111 return 1;
1112
Willy Tarreaubaaee002006-06-26 02:48:02 +02001113 case SRV_STATUS_INTERNAL:
1114 default:
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001115 if (!t->req->cons->err_type) {
1116 t->req->cons->err_type = SI_ET_CONN_OTHER;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001117 }
1118
Willy Tarreau827aee92011-03-10 16:55:02 +01001119 if (srv)
1120 srv_inc_sess_ctr(srv);
1121 if (srv)
1122 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001123 t->be->be_counters.failed_conns++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001124
1125 /* release other sessions waiting for this server */
Willy Tarreau827aee92011-03-10 16:55:02 +01001126 if (may_dequeue_tasks(srv, t->be))
1127 process_srv_queue(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001128 return 1;
1129 }
1130 /* if we get here, it's because we got SRV_STATUS_OK, which also
1131 * means that the connection has not been queued.
1132 */
1133 return 0;
1134}
1135
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001136/* Apply RDP cookie persistence to the current session. For this, the function
1137 * tries to extract an RDP cookie from the request buffer, and look for the
1138 * matching server in the list. If the server is found, it is assigned to the
1139 * session. This always returns 1, and the analyser removes itself from the
1140 * list. Nothing is performed if a server was already assigned.
1141 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001142int tcp_persist_rdp_cookie(struct session *s, struct channel *req, int an_bit)
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001143{
1144 struct proxy *px = s->be;
1145 int ret;
Willy Tarreau37406352012-04-23 16:16:37 +02001146 struct sample smp;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001147 struct server *srv = px->srv;
1148 struct sockaddr_in addr;
1149 char *p;
1150
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001151 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 +02001152 now_ms, __FUNCTION__,
1153 s,
1154 req,
1155 req->rex, req->wex,
1156 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001157 req->buf->i,
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001158 req->analysers);
1159
1160 if (s->flags & SN_ASSIGNED)
1161 goto no_cookie;
1162
Willy Tarreau37406352012-04-23 16:16:37 +02001163 memset(&smp, 0, sizeof(smp));
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001164
Willy Tarreaucadd8c92013-07-22 18:09:52 +02001165 ret = fetch_rdp_cookie_name(s, &smp, s->be->rdp_cookie_name, s->be->rdp_cookie_len);
Willy Tarreauf853c462012-04-23 18:53:56 +02001166 if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || smp.data.str.len == 0)
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001167 goto no_cookie;
1168
1169 memset(&addr, 0, sizeof(addr));
1170 addr.sin_family = AF_INET;
1171
Willy Tarreau664092c2011-12-16 19:11:42 +01001172 /* Considering an rdp cookie detected using acl, str ended with <cr><lf> and should return */
Willy Tarreauf853c462012-04-23 18:53:56 +02001173 addr.sin_addr.s_addr = strtoul(smp.data.str.str, &p, 10);
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001174 if (*p != '.')
1175 goto no_cookie;
1176 p++;
1177 addr.sin_port = (unsigned short)strtoul(p, &p, 10);
1178 if (*p != '.')
1179 goto no_cookie;
1180
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001181 s->target = NULL;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001182 while (srv) {
1183 if (memcmp(&addr, &(srv->addr), sizeof(addr)) == 0) {
1184 if ((srv->state & SRV_RUNNING) || (px->options & PR_O_PERSIST)) {
1185 /* we found the server and it is usable */
1186 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001187 s->target = &srv->obj_type;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001188 break;
1189 }
1190 }
1191 srv = srv->next;
1192 }
1193
1194no_cookie:
1195 req->analysers &= ~an_bit;
1196 req->analyse_exp = TICK_ETERNITY;
1197 return 1;
1198}
1199
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001200int be_downtime(struct proxy *px) {
Willy Tarreaub625a082007-11-26 01:15:43 +01001201 if (px->lbprm.tot_weight && px->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001202 return px->down_time;
1203
1204 return now.tv_sec - px->last_change + px->down_time;
1205}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001206
Krzysztof Piotr Oledzki15514c22010-01-04 16:03:09 +01001207/*
1208 * This function returns a string containing the balancing
1209 * mode of the proxy in a format suitable for stats.
1210 */
1211
1212const char *backend_lb_algo_str(int algo) {
1213
1214 if (algo == BE_LB_ALGO_RR)
1215 return "roundrobin";
1216 else if (algo == BE_LB_ALGO_SRR)
1217 return "static-rr";
Willy Tarreauf09c6602012-02-13 17:12:08 +01001218 else if (algo == BE_LB_ALGO_FAS)
1219 return "first";
Krzysztof Piotr Oledzki15514c22010-01-04 16:03:09 +01001220 else if (algo == BE_LB_ALGO_LC)
1221 return "leastconn";
1222 else if (algo == BE_LB_ALGO_SH)
1223 return "source";
1224 else if (algo == BE_LB_ALGO_UH)
1225 return "uri";
1226 else if (algo == BE_LB_ALGO_PH)
1227 return "url_param";
1228 else if (algo == BE_LB_ALGO_HH)
1229 return "hdr";
1230 else if (algo == BE_LB_ALGO_RCH)
1231 return "rdp-cookie";
1232 else
1233 return NULL;
1234}
1235
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001236/* This function parses a "balance" statement in a backend section describing
1237 * <curproxy>. It returns -1 if there is any error, otherwise zero. If it
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001238 * returns -1, it will write an error message into the <err> buffer which will
1239 * automatically be allocated and must be passed as NULL. The trailing '\n'
1240 * will not be written. The function must be called with <args> pointing to the
1241 * first word after "balance".
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001242 */
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001243int backend_parse_balance(const char **args, char **err, struct proxy *curproxy)
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001244{
1245 if (!*(args[0])) {
1246 /* if no option is set, use round-robin by default */
Willy Tarreau31682232007-11-29 15:38:04 +01001247 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1248 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001249 return 0;
1250 }
1251
1252 if (!strcmp(args[0], "roundrobin")) {
Willy Tarreau31682232007-11-29 15:38:04 +01001253 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1254 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001255 }
Willy Tarreau9757a382009-10-03 12:56:50 +02001256 else if (!strcmp(args[0], "static-rr")) {
1257 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1258 curproxy->lbprm.algo |= BE_LB_ALGO_SRR;
1259 }
Willy Tarreauf09c6602012-02-13 17:12:08 +01001260 else if (!strcmp(args[0], "first")) {
1261 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1262 curproxy->lbprm.algo |= BE_LB_ALGO_FAS;
1263 }
Willy Tarreau51406232008-03-10 22:04:20 +01001264 else if (!strcmp(args[0], "leastconn")) {
1265 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1266 curproxy->lbprm.algo |= BE_LB_ALGO_LC;
1267 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001268 else if (!strcmp(args[0], "source")) {
Willy Tarreau31682232007-11-29 15:38:04 +01001269 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1270 curproxy->lbprm.algo |= BE_LB_ALGO_SH;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001271 }
1272 else if (!strcmp(args[0], "uri")) {
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001273 int arg = 1;
1274
Willy Tarreau31682232007-11-29 15:38:04 +01001275 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1276 curproxy->lbprm.algo |= BE_LB_ALGO_UH;
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001277
Oskar Stolc8dc41842012-05-19 10:19:54 +01001278 curproxy->uri_whole = 0;
1279
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001280 while (*args[arg]) {
1281 if (!strcmp(args[arg], "len")) {
1282 if (!*args[arg+1] || (atoi(args[arg+1]) <= 0)) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001283 memprintf(err, "%s : '%s' expects a positive integer (got '%s').", args[0], args[arg], args[arg+1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001284 return -1;
1285 }
1286 curproxy->uri_len_limit = atoi(args[arg+1]);
1287 arg += 2;
1288 }
1289 else if (!strcmp(args[arg], "depth")) {
1290 if (!*args[arg+1] || (atoi(args[arg+1]) <= 0)) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001291 memprintf(err, "%s : '%s' expects a positive integer (got '%s').", args[0], args[arg], args[arg+1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001292 return -1;
1293 }
1294 /* hint: we store the position of the ending '/' (depth+1) so
1295 * that we avoid a comparison while computing the hash.
1296 */
1297 curproxy->uri_dirs_depth1 = atoi(args[arg+1]) + 1;
1298 arg += 2;
1299 }
Oskar Stolc8dc41842012-05-19 10:19:54 +01001300 else if (!strcmp(args[arg], "whole")) {
1301 curproxy->uri_whole = 1;
1302 arg += 1;
1303 }
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001304 else {
Oskar Stolc8dc41842012-05-19 10:19:54 +01001305 memprintf(err, "%s only accepts parameters 'len', 'depth', and 'whole' (got '%s').", args[0], args[arg]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001306 return -1;
1307 }
1308 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001309 }
Willy Tarreau01732802007-11-01 22:48:15 +01001310 else if (!strcmp(args[0], "url_param")) {
1311 if (!*args[1]) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001312 memprintf(err, "%s requires an URL parameter name.", args[0]);
Willy Tarreau01732802007-11-01 22:48:15 +01001313 return -1;
1314 }
Willy Tarreau31682232007-11-29 15:38:04 +01001315 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1316 curproxy->lbprm.algo |= BE_LB_ALGO_PH;
Willy Tarreaua534fea2008-08-03 12:19:50 +02001317
1318 free(curproxy->url_param_name);
Willy Tarreau01732802007-11-01 22:48:15 +01001319 curproxy->url_param_name = strdup(args[1]);
Willy Tarreaua534fea2008-08-03 12:19:50 +02001320 curproxy->url_param_len = strlen(args[1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001321 if (*args[2]) {
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001322 if (strcmp(args[2], "check_post")) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001323 memprintf(err, "%s only accepts 'check_post' modifier (got '%s').", args[0], args[2]);
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001324 return -1;
1325 }
1326 if (*args[3]) {
1327 /* TODO: maybe issue a warning if there is no value, no digits or too long */
1328 curproxy->url_param_post_limit = str2ui(args[3]);
1329 }
1330 /* if no limit, or faul value in args[3], then default to a moderate wordlen */
1331 if (!curproxy->url_param_post_limit)
1332 curproxy->url_param_post_limit = 48;
1333 else if ( curproxy->url_param_post_limit < 3 )
1334 curproxy->url_param_post_limit = 3; /* minimum example: S=3 or \r\nS=6& */
1335 }
Benoitaffb4812009-03-25 13:02:10 +01001336 }
1337 else if (!strncmp(args[0], "hdr(", 4)) {
1338 const char *beg, *end;
1339
1340 beg = args[0] + 4;
1341 end = strchr(beg, ')');
1342
1343 if (!end || end == beg) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001344 memprintf(err, "hdr requires an http header field name.");
Benoitaffb4812009-03-25 13:02:10 +01001345 return -1;
1346 }
1347
1348 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1349 curproxy->lbprm.algo |= BE_LB_ALGO_HH;
1350
1351 free(curproxy->hh_name);
1352 curproxy->hh_len = end - beg;
1353 curproxy->hh_name = my_strndup(beg, end - beg);
1354 curproxy->hh_match_domain = 0;
1355
1356 if (*args[1]) {
1357 if (strcmp(args[1], "use_domain_only")) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001358 memprintf(err, "%s only accepts 'use_domain_only' modifier (got '%s').", args[0], args[1]);
Benoitaffb4812009-03-25 13:02:10 +01001359 return -1;
1360 }
1361 curproxy->hh_match_domain = 1;
1362 }
Emeric Brun736aa232009-06-30 17:56:00 +02001363 }
1364 else if (!strncmp(args[0], "rdp-cookie", 10)) {
1365 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1366 curproxy->lbprm.algo |= BE_LB_ALGO_RCH;
1367
1368 if ( *(args[0] + 10 ) == '(' ) { /* cookie name */
1369 const char *beg, *end;
1370
1371 beg = args[0] + 11;
1372 end = strchr(beg, ')');
1373
1374 if (!end || end == beg) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001375 memprintf(err, "rdp-cookie : missing cookie name.");
Emeric Brun736aa232009-06-30 17:56:00 +02001376 return -1;
1377 }
1378
1379 free(curproxy->hh_name);
1380 curproxy->hh_name = my_strndup(beg, end - beg);
1381 curproxy->hh_len = end - beg;
1382 }
1383 else if ( *(args[0] + 10 ) == '\0' ) { /* default cookie name 'mstshash' */
1384 free(curproxy->hh_name);
1385 curproxy->hh_name = strdup("mstshash");
1386 curproxy->hh_len = strlen(curproxy->hh_name);
1387 }
1388 else { /* syntax */
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001389 memprintf(err, "rdp-cookie : missing cookie name.");
Emeric Brun736aa232009-06-30 17:56:00 +02001390 return -1;
1391 }
Willy Tarreau01732802007-11-01 22:48:15 +01001392 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001393 else {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001394 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 +01001395 return -1;
1396 }
1397 return 0;
1398}
1399
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001400
1401/************************************************************************/
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001402/* All supported sample and ACL keywords must be declared here. */
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001403/************************************************************************/
1404
Willy Tarreau34db1082012-04-19 17:16:54 +02001405/* set temp integer to the number of enabled servers on the proxy.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001406 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001407 * undefined behaviour.
1408 */
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001409static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001410smp_fetch_nbsrv(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001411 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001412{
Willy Tarreau37406352012-04-23 16:16:37 +02001413 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001414 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001415 px = args->data.prx;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001416
1417 if (px->srv_act)
Willy Tarreauf853c462012-04-23 18:53:56 +02001418 smp->data.uint = px->srv_act;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001419 else if (px->lbprm.fbck)
Willy Tarreauf853c462012-04-23 18:53:56 +02001420 smp->data.uint = 1;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001421 else
Willy Tarreauf853c462012-04-23 18:53:56 +02001422 smp->data.uint = px->srv_bck;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001423
1424 return 1;
1425}
1426
Willy Tarreau37406352012-04-23 16:16:37 +02001427/* report in smp->flags a success or failure depending on the designated
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001428 * server's state. There is no match function involved since there's no pattern.
Willy Tarreau34db1082012-04-19 17:16:54 +02001429 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1430 * undefined behaviour.
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001431 */
1432static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001433smp_fetch_srv_is_up(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001434 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001435{
Willy Tarreau24e32d82012-04-23 23:55:44 +02001436 struct server *srv = args->data.srv;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001437
Willy Tarreau37406352012-04-23 16:16:37 +02001438 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001439 smp->type = SMP_T_BOOL;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001440 if (!(srv->state & SRV_MAINTAIN) &&
1441 (!(srv->state & SRV_CHECKED) || (srv->state & SRV_RUNNING)))
Willy Tarreau197e10a2012-04-23 19:18:42 +02001442 smp->data.uint = 1;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001443 else
Willy Tarreau197e10a2012-04-23 19:18:42 +02001444 smp->data.uint = 0;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001445 return 1;
1446}
1447
Willy Tarreau34db1082012-04-19 17:16:54 +02001448/* set temp integer to the number of enabled servers on the proxy.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001449 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001450 * undefined behaviour.
1451 */
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001452static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001453smp_fetch_connslots(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001454 const struct arg *args, struct sample *smp, const char *kw)
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001455{
1456 struct server *iterator;
Willy Tarreaud28c3532012-04-19 19:28:33 +02001457
Willy Tarreau37406352012-04-23 16:16:37 +02001458 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001459 smp->type = SMP_T_UINT;
1460 smp->data.uint = 0;
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001461
Willy Tarreau24e32d82012-04-23 23:55:44 +02001462 for (iterator = args->data.prx->srv; iterator; iterator = iterator->next) {
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001463 if ((iterator->state & SRV_RUNNING) == 0)
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001464 continue;
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001465
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001466 if (iterator->maxconn == 0 || iterator->maxqueue == 0) {
Willy Tarreaua5e37562011-12-16 17:06:15 +01001467 /* configuration is stupid */
Willy Tarreauf853c462012-04-23 18:53:56 +02001468 smp->data.uint = -1; /* FIXME: stupid value! */
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001469 return 1;
1470 }
1471
Willy Tarreauf853c462012-04-23 18:53:56 +02001472 smp->data.uint += (iterator->maxconn - iterator->cur_sess)
Willy Tarreau422aa072012-04-20 20:49:27 +02001473 + (iterator->maxqueue - iterator->nbpend);
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001474 }
1475
1476 return 1;
1477}
1478
Willy Tarreaua5e37562011-12-16 17:06:15 +01001479/* set temp integer to the id of the backend */
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001480static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001481smp_fetch_be_id(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001482 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau37406352012-04-23 16:16:37 +02001483{
Willy Tarreauf853c462012-04-23 18:53:56 +02001484 smp->flags = SMP_F_VOL_TXN;
1485 smp->type = SMP_T_UINT;
1486 smp->data.uint = l4->be->uuid;
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001487 return 1;
1488}
1489
Willy Tarreaua5e37562011-12-16 17:06:15 +01001490/* set temp integer to the id of the server */
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001491static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001492smp_fetch_srv_id(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001493 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau37406352012-04-23 16:16:37 +02001494{
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001495 if (!objt_server(l4->target))
Willy Tarreau17af4192011-02-23 14:27:06 +01001496 return 0;
1497
Willy Tarreauf853c462012-04-23 18:53:56 +02001498 smp->type = SMP_T_UINT;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001499 smp->data.uint = objt_server(l4->target)->puid;
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001500
1501 return 1;
1502}
1503
Willy Tarreau34db1082012-04-19 17:16:54 +02001504/* set temp integer to the number of connections per second reaching the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001505 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001506 * undefined behaviour.
1507 */
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001508static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001509smp_fetch_be_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001510 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001511{
Willy Tarreau37406352012-04-23 16:16:37 +02001512 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001513 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001514 smp->data.uint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001515 return 1;
1516}
1517
Willy Tarreau34db1082012-04-19 17:16:54 +02001518/* set temp integer to the number of concurrent connections on the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001519 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001520 * undefined behaviour.
1521 */
Willy Tarreaua36af912009-10-10 12:02:45 +02001522static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001523smp_fetch_be_conn(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001524 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001525{
Willy Tarreau37406352012-04-23 16:16:37 +02001526 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001527 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001528 smp->data.uint = args->data.prx->beconn;
Willy Tarreaua36af912009-10-10 12:02:45 +02001529 return 1;
1530}
1531
Willy Tarreau34db1082012-04-19 17:16:54 +02001532/* set temp integer to the total number of queued connections on the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001533 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001534 * undefined behaviour.
1535 */
Willy Tarreaua36af912009-10-10 12:02:45 +02001536static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001537smp_fetch_queue_size(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001538 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001539{
Willy Tarreau37406352012-04-23 16:16:37 +02001540 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001541 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001542 smp->data.uint = args->data.prx->totpend;
Willy Tarreaua36af912009-10-10 12:02:45 +02001543 return 1;
1544}
1545
Willy Tarreaua5e37562011-12-16 17:06:15 +01001546/* set temp integer to the total number of queued connections on the backend divided
Willy Tarreaua36af912009-10-10 12:02:45 +02001547 * by the number of running servers and rounded up. If there is no running
1548 * server, we return twice the total, just as if we had half a running server.
1549 * This is more or less correct anyway, since we expect the last server to come
1550 * back soon.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001551 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001552 * undefined behaviour.
Willy Tarreaua36af912009-10-10 12:02:45 +02001553 */
1554static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001555smp_fetch_avg_queue_size(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001556 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001557{
1558 int nbsrv;
1559
Willy Tarreau37406352012-04-23 16:16:37 +02001560 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001561 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001562 px = args->data.prx;
Willy Tarreaua36af912009-10-10 12:02:45 +02001563
1564 if (px->srv_act)
1565 nbsrv = px->srv_act;
1566 else if (px->lbprm.fbck)
1567 nbsrv = 1;
1568 else
1569 nbsrv = px->srv_bck;
1570
1571 if (nbsrv > 0)
Willy Tarreauf853c462012-04-23 18:53:56 +02001572 smp->data.uint = (px->totpend + nbsrv - 1) / nbsrv;
Willy Tarreaua36af912009-10-10 12:02:45 +02001573 else
Willy Tarreauf853c462012-04-23 18:53:56 +02001574 smp->data.uint = px->totpend * 2;
Willy Tarreaua36af912009-10-10 12:02:45 +02001575
1576 return 1;
1577}
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001578
Willy Tarreau34db1082012-04-19 17:16:54 +02001579/* set temp integer to the number of concurrent connections on the server in the backend.
1580 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1581 * undefined behaviour.
1582 */
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001583static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001584smp_fetch_srv_conn(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001585 const struct arg *args, struct sample *smp, const char *kw)
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001586{
Willy Tarreauf853c462012-04-23 18:53:56 +02001587 smp->flags = SMP_F_VOL_TEST;
1588 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001589 smp->data.uint = args->data.srv->cur_sess;
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001590 return 1;
1591}
1592
Tait Clarridge7896d522012-12-05 21:39:31 -05001593/* set temp integer to the number of enabled servers on the proxy.
1594 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1595 * undefined behaviour.
1596 */
1597static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001598smp_fetch_srv_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001599 const struct arg *args, struct sample *smp, const char *kw)
Tait Clarridge7896d522012-12-05 21:39:31 -05001600{
1601 smp->flags = SMP_F_VOL_TEST;
1602 smp->type = SMP_T_UINT;
1603 smp->data.uint = read_freq_ctr(&args->data.srv->sess_per_sec);
1604 return 1;
1605}
1606
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001607
1608/* Note: must not be declared <const> as its list will be overwritten.
1609 * Please take care of keeping this list alphabetically sorted.
1610 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001611static struct sample_fetch_kw_list smp_kws = {ILH, {
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001612 { "avg_queue", smp_fetch_avg_queue_size, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1613 { "be_conn", smp_fetch_be_conn, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1614 { "be_id", smp_fetch_be_id, 0, NULL, SMP_T_UINT, SMP_USE_BKEND, },
1615 { "be_sess_rate", smp_fetch_be_sess_rate, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1616 { "connslots", smp_fetch_connslots, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1617 { "nbsrv", smp_fetch_nbsrv, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1618 { "queue", smp_fetch_queue_size, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1619 { "srv_conn", smp_fetch_srv_conn, ARG1(1,SRV), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1620 { "srv_id", smp_fetch_srv_id, 0, NULL, SMP_T_UINT, SMP_USE_SERVR, },
1621 { "srv_is_up", smp_fetch_srv_is_up, ARG1(1,SRV), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
1622 { "srv_sess_rate", smp_fetch_srv_sess_rate, ARG1(1,SRV), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1623 { /* END */ },
1624}};
1625
1626
Willy Tarreau61612d42012-04-19 18:42:05 +02001627/* Note: must not be declared <const> as its list will be overwritten.
1628 * Please take care of keeping this list alphabetically sorted.
1629 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001630static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001631 { /* END */ },
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001632}};
1633
1634
1635__attribute__((constructor))
1636static void __backend_init(void)
1637{
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001638 sample_register_fetches(&smp_kws);
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001639 acl_register_keywords(&acl_kws);
1640}
1641
Willy Tarreaubaaee002006-06-26 02:48:02 +02001642/*
1643 * Local variables:
1644 * c-indent-level: 8
1645 * c-basic-offset: 8
1646 * End:
1647 */