blob: 212e779b2cbe5c75c849ad28e43a8e52a952a170 [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
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050055int be_lastsession(const struct proxy *be)
56{
57 if (be->be_counters.last_sess)
58 return now.tv_sec - be->be_counters.last_sess;
59
60 return -1;
61}
62
Bhaskar98634f02013-10-29 23:30:51 -040063/* helper function to invoke the correct hash method */
64static unsigned long gen_hash(const struct proxy* px, const char* key, unsigned long len)
65{
66 unsigned long hash;
67
68 switch (px->lbprm.algo & BE_LB_HASH_FUNC) {
69 case BE_LB_HFCN_DJB2:
70 hash = hash_djb2(key, len);
71 break;
Willy Tarreaua0f42712013-11-14 14:30:35 +010072 case BE_LB_HFCN_WT6:
73 hash = hash_wt6(key, len);
74 break;
Bhaskar98634f02013-10-29 23:30:51 -040075 case BE_LB_HFCN_SDBM:
76 /* this is the default hash function */
77 default:
78 hash = hash_sdbm(key, len);
79 break;
80 }
81
82 return hash;
83}
84
Willy Tarreaubaaee002006-06-26 02:48:02 +020085/*
86 * This function recounts the number of usable active and backup servers for
87 * proxy <p>. These numbers are returned into the p->srv_act and p->srv_bck.
Willy Tarreaub625a082007-11-26 01:15:43 +010088 * This function also recomputes the total active and backup weights. However,
Willy Tarreauf4cca452008-03-08 21:42:54 +010089 * it does not update tot_weight nor tot_used. Use update_backend_weight() for
Willy Tarreaub625a082007-11-26 01:15:43 +010090 * this.
Willy Tarreaubaaee002006-06-26 02:48:02 +020091 */
Willy Tarreauc5d9c802009-10-01 09:17:05 +020092void recount_servers(struct proxy *px)
Willy Tarreaubaaee002006-06-26 02:48:02 +020093{
94 struct server *srv;
95
Willy Tarreau20697042007-11-15 23:26:18 +010096 px->srv_act = px->srv_bck = 0;
97 px->lbprm.tot_wact = px->lbprm.tot_wbck = 0;
Willy Tarreaub625a082007-11-26 01:15:43 +010098 px->lbprm.fbck = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +020099 for (srv = px->srv; srv != NULL; srv = srv->next) {
Willy Tarreaub625a082007-11-26 01:15:43 +0100100 if (!srv_is_usable(srv->state, srv->eweight))
101 continue;
102
103 if (srv->state & SRV_BACKUP) {
104 if (!px->srv_bck &&
Willy Tarreauf4cca452008-03-08 21:42:54 +0100105 !(px->options & PR_O_USE_ALL_BK))
Willy Tarreaub625a082007-11-26 01:15:43 +0100106 px->lbprm.fbck = srv;
107 px->srv_bck++;
108 px->lbprm.tot_wbck += srv->eweight;
109 } else {
110 px->srv_act++;
111 px->lbprm.tot_wact += srv->eweight;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200112 }
113 }
Willy Tarreaub625a082007-11-26 01:15:43 +0100114}
Willy Tarreau20697042007-11-15 23:26:18 +0100115
Willy Tarreaub625a082007-11-26 01:15:43 +0100116/* This function simply updates the backend's tot_weight and tot_used values
117 * after servers weights have been updated. It is designed to be used after
118 * recount_servers() or equivalent.
119 */
Willy Tarreauc5d9c802009-10-01 09:17:05 +0200120void update_backend_weight(struct proxy *px)
Willy Tarreaub625a082007-11-26 01:15:43 +0100121{
Willy Tarreau20697042007-11-15 23:26:18 +0100122 if (px->srv_act) {
123 px->lbprm.tot_weight = px->lbprm.tot_wact;
124 px->lbprm.tot_used = px->srv_act;
125 }
Willy Tarreaub625a082007-11-26 01:15:43 +0100126 else if (px->lbprm.fbck) {
127 /* use only the first backup server */
128 px->lbprm.tot_weight = px->lbprm.fbck->eweight;
129 px->lbprm.tot_used = 1;
Willy Tarreau20697042007-11-15 23:26:18 +0100130 }
131 else {
Willy Tarreaub625a082007-11-26 01:15:43 +0100132 px->lbprm.tot_weight = px->lbprm.tot_wbck;
133 px->lbprm.tot_used = px->srv_bck;
Willy Tarreau20697042007-11-15 23:26:18 +0100134 }
Willy Tarreaub625a082007-11-26 01:15:43 +0100135}
136
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200137/*
138 * This function tries to find a running server for the proxy <px> following
139 * the source hash method. Depending on the number of active/backup servers,
140 * it will either look for active servers, or for backup servers.
141 * If any server is found, it will be returned. If no valid server is found,
142 * NULL is returned.
143 */
144struct server *get_server_sh(struct proxy *px, const char *addr, int len)
145{
146 unsigned int h, l;
147
148 if (px->lbprm.tot_weight == 0)
149 return NULL;
150
151 l = h = 0;
152
153 /* note: we won't hash if there's only one server left */
154 if (px->lbprm.tot_used == 1)
155 goto hash_done;
156
157 while ((l + sizeof (int)) <= len) {
158 h ^= ntohl(*(unsigned int *)(&addr[l]));
159 l += sizeof (int);
160 }
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500161 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100162 h = full_hash(h);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200163 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200164 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
165 return chash_get_server_hash(px, h);
166 else
167 return map_get_server_hash(px, h);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200168}
169
170/*
171 * This function tries to find a running server for the proxy <px> following
172 * the URI hash method. In order to optimize cache hits, the hash computation
173 * ends at the question mark. Depending on the number of active/backup servers,
174 * it will either look for active servers, or for backup servers.
175 * If any server is found, it will be returned. If no valid server is found,
176 * NULL is returned.
177 *
178 * This code was contributed by Guillaume Dallaire, who also selected this hash
179 * algorithm out of a tens because it gave him the best results.
180 *
181 */
182struct server *get_server_uh(struct proxy *px, char *uri, int uri_len)
183{
184 unsigned long hash = 0;
185 int c;
186 int slashes = 0;
Bhaskar98634f02013-10-29 23:30:51 -0400187 const char *start, *end;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200188
189 if (px->lbprm.tot_weight == 0)
190 return NULL;
191
192 /* note: we won't hash if there's only one server left */
193 if (px->lbprm.tot_used == 1)
194 goto hash_done;
195
196 if (px->uri_len_limit)
197 uri_len = MIN(uri_len, px->uri_len_limit);
198
Bhaskar98634f02013-10-29 23:30:51 -0400199 start = end = uri;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200200 while (uri_len--) {
Bhaskar98634f02013-10-29 23:30:51 -0400201 c = *end++;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200202 if (c == '/') {
203 slashes++;
204 if (slashes == px->uri_dirs_depth1) /* depth+1 */
205 break;
206 }
Oskar Stolc8dc41842012-05-19 10:19:54 +0100207 else if (c == '?' && !px->uri_whole)
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200208 break;
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200209 }
Bhaskar98634f02013-10-29 23:30:51 -0400210
211 hash = gen_hash(px, start, (end - start));
212
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500213 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100214 hash = full_hash(hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200215 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200216 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
217 return chash_get_server_hash(px, hash);
218 else
219 return map_get_server_hash(px, hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200220}
221
Willy Tarreau01732802007-11-01 22:48:15 +0100222/*
223 * This function tries to find a running server for the proxy <px> following
224 * the URL parameter hash method. It looks for a specific parameter in the
225 * URL and hashes it to compute the server ID. This is useful to optimize
226 * performance by avoiding bounces between servers in contexts where sessions
227 * are shared but cookies are not usable. If the parameter is not found, NULL
228 * is returned. If any server is found, it will be returned. If no valid server
229 * is found, NULL is returned.
Willy Tarreau01732802007-11-01 22:48:15 +0100230 */
231struct server *get_server_ph(struct proxy *px, const char *uri, int uri_len)
232{
233 unsigned long hash = 0;
Bhaskar98634f02013-10-29 23:30:51 -0400234 const char *start, *end;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200235 const char *p;
236 const char *params;
Willy Tarreau01732802007-11-01 22:48:15 +0100237 int plen;
238
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200239 /* when tot_weight is 0 then so is srv_count */
Willy Tarreau20697042007-11-15 23:26:18 +0100240 if (px->lbprm.tot_weight == 0)
Willy Tarreau01732802007-11-01 22:48:15 +0100241 return NULL;
242
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200243 if ((p = memchr(uri, '?', uri_len)) == NULL)
244 return NULL;
245
Willy Tarreau01732802007-11-01 22:48:15 +0100246 p++;
247
248 uri_len -= (p - uri);
249 plen = px->url_param_len;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200250 params = p;
Willy Tarreau01732802007-11-01 22:48:15 +0100251
252 while (uri_len > plen) {
253 /* Look for the parameter name followed by an equal symbol */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200254 if (params[plen] == '=') {
255 if (memcmp(params, px->url_param_name, plen) == 0) {
256 /* OK, we have the parameter here at <params>, and
Willy Tarreau01732802007-11-01 22:48:15 +0100257 * the value after the equal sign, at <p>
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200258 * skip the equal symbol
Willy Tarreau01732802007-11-01 22:48:15 +0100259 */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200260 p += plen + 1;
Bhaskar98634f02013-10-29 23:30:51 -0400261 start = end = p;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200262 uri_len -= plen + 1;
263
Bhaskar98634f02013-10-29 23:30:51 -0400264 while (uri_len && *end != '&') {
Willy Tarreau01732802007-11-01 22:48:15 +0100265 uri_len--;
Bhaskar98634f02013-10-29 23:30:51 -0400266 end++;
Willy Tarreau01732802007-11-01 22:48:15 +0100267 }
Bhaskar98634f02013-10-29 23:30:51 -0400268 hash = gen_hash(px, start, (end - start));
269
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500270 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100271 hash = full_hash(hash);
Bhaskar98634f02013-10-29 23:30:51 -0400272
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200273 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
274 return chash_get_server_hash(px, hash);
275 else
276 return map_get_server_hash(px, hash);
Willy Tarreau01732802007-11-01 22:48:15 +0100277 }
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200278 }
279 /* skip to next parameter */
280 p = memchr(params, '&', uri_len);
281 if (!p)
282 return NULL;
283 p++;
284 uri_len -= (p - params);
285 params = p;
286 }
287 return NULL;
288}
289
290/*
291 * this does the same as the previous server_ph, but check the body contents
292 */
293struct server *get_server_ph_post(struct session *s)
294{
295 unsigned long hash = 0;
296 struct http_txn *txn = &s->txn;
Willy Tarreau7421efb2012-07-02 15:11:27 +0200297 struct channel *req = s->req;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200298 struct http_msg *msg = &txn->req;
299 struct proxy *px = s->be;
300 unsigned int plen = px->url_param_len;
Willy Tarreau2d8e4852014-04-17 20:08:17 +0200301 unsigned long len = http_body_bytes(msg);
Willy Tarreau211cdec2014-04-17 20:18:08 +0200302 const char *params = b_ptr(req->buf, (int)(msg->sov + msg->sol - http_hdr_rewind(msg)));
Willy Tarreau157dd632009-12-06 19:18:09 +0100303 const char *p = params;
Bhaskar98634f02013-10-29 23:30:51 -0400304 const char *start, *end;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200305
Willy Tarreau157dd632009-12-06 19:18:09 +0100306 if (len == 0)
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200307 return NULL;
308
Willy Tarreau157dd632009-12-06 19:18:09 +0100309 if (px->lbprm.tot_weight == 0)
310 return NULL;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200311
312 while (len > plen) {
313 /* Look for the parameter name followed by an equal symbol */
314 if (params[plen] == '=') {
315 if (memcmp(params, px->url_param_name, plen) == 0) {
316 /* OK, we have the parameter here at <params>, and
317 * the value after the equal sign, at <p>
318 * skip the equal symbol
319 */
320 p += plen + 1;
Bhaskar98634f02013-10-29 23:30:51 -0400321 start = end = p;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200322 len -= plen + 1;
323
Bhaskar98634f02013-10-29 23:30:51 -0400324 while (len && *end != '&') {
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200325 if (unlikely(!HTTP_IS_TOKEN(*p))) {
Willy Tarreau157dd632009-12-06 19:18:09 +0100326 /* if in a POST, body must be URI encoded or it's not a URI.
Bhaskar98634f02013-10-29 23:30:51 -0400327 * Do not interpret any possible binary data as a parameter.
Willy Tarreau157dd632009-12-06 19:18:09 +0100328 */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200329 if (likely(HTTP_IS_LWS(*p))) /* eol, uncertain uri len */
330 break;
331 return NULL; /* oh, no; this is not uri-encoded.
332 * This body does not contain parameters.
333 */
334 }
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200335 len--;
Bhaskar98634f02013-10-29 23:30:51 -0400336 end++;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200337 /* should we break if vlen exceeds limit? */
338 }
Bhaskar98634f02013-10-29 23:30:51 -0400339 hash = gen_hash(px, start, (end - start));
340
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500341 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100342 hash = full_hash(hash);
Bhaskar98634f02013-10-29 23:30:51 -0400343
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200344 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
345 return chash_get_server_hash(px, hash);
346 else
347 return map_get_server_hash(px, hash);
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200348 }
349 }
Willy Tarreau01732802007-11-01 22:48:15 +0100350 /* skip to next parameter */
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200351 p = memchr(params, '&', len);
Willy Tarreau01732802007-11-01 22:48:15 +0100352 if (!p)
353 return NULL;
354 p++;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200355 len -= (p - params);
356 params = p;
Willy Tarreau01732802007-11-01 22:48:15 +0100357 }
358 return NULL;
359}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200360
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200361
Willy Tarreaubaaee002006-06-26 02:48:02 +0200362/*
Benoitaffb4812009-03-25 13:02:10 +0100363 * This function tries to find a running server for the proxy <px> following
364 * the Header parameter hash method. It looks for a specific parameter in the
365 * URL and hashes it to compute the server ID. This is useful to optimize
366 * performance by avoiding bounces between servers in contexts where sessions
367 * are shared but cookies are not usable. If the parameter is not found, NULL
368 * is returned. If any server is found, it will be returned. If no valid server
369 * is found, NULL is returned.
370 */
371struct server *get_server_hh(struct session *s)
372{
373 unsigned long hash = 0;
374 struct http_txn *txn = &s->txn;
Benoitaffb4812009-03-25 13:02:10 +0100375 struct proxy *px = s->be;
376 unsigned int plen = px->hh_len;
377 unsigned long len;
378 struct hdr_ctx ctx;
379 const char *p;
Bhaskar98634f02013-10-29 23:30:51 -0400380 const char *start, *end;
Benoitaffb4812009-03-25 13:02:10 +0100381
382 /* tot_weight appears to mean srv_count */
383 if (px->lbprm.tot_weight == 0)
384 return NULL;
385
Benoitaffb4812009-03-25 13:02:10 +0100386 ctx.idx = 0;
387
388 /* if the message is chunked, we skip the chunk size, but use the value as len */
Willy Tarreau211cdec2014-04-17 20:18:08 +0200389 http_find_header2(px->hh_name, plen, b_ptr(s->req->buf, -http_hdr_rewind(&txn->req)), &txn->hdr_idx, &ctx);
Benoitaffb4812009-03-25 13:02:10 +0100390
391 /* if the header is not found or empty, let's fallback to round robin */
392 if (!ctx.idx || !ctx.vlen)
393 return NULL;
394
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200395 /* note: we won't hash if there's only one server left */
396 if (px->lbprm.tot_used == 1)
397 goto hash_done;
398
Benoitaffb4812009-03-25 13:02:10 +0100399 /* Found a the hh_name in the headers.
400 * we will compute the hash based on this value ctx.val.
401 */
402 len = ctx.vlen;
403 p = (char *)ctx.line + ctx.val;
404 if (!px->hh_match_domain) {
Bhaskar98634f02013-10-29 23:30:51 -0400405 hash = gen_hash(px, p, len);
Benoitaffb4812009-03-25 13:02:10 +0100406 } else {
407 int dohash = 0;
408 p += len - 1;
Bhaskar98634f02013-10-29 23:30:51 -0400409 start = end = p;
Benoitaffb4812009-03-25 13:02:10 +0100410 /* special computation, use only main domain name, not tld/host
411 * going back from the end of string, start hashing at first
412 * dot stop at next.
413 * This is designed to work with the 'Host' header, and requires
414 * a special option to activate this.
415 */
416 while (len) {
417 if (*p == '.') {
Bhaskar98634f02013-10-29 23:30:51 -0400418 if (!dohash) {
Benoitaffb4812009-03-25 13:02:10 +0100419 dohash = 1;
Bhaskar98634f02013-10-29 23:30:51 -0400420 start = end = p - 1;
421 }
Benoitaffb4812009-03-25 13:02:10 +0100422 else
423 break;
424 } else {
425 if (dohash)
Bhaskar98634f02013-10-29 23:30:51 -0400426 start--;
Benoitaffb4812009-03-25 13:02:10 +0100427 }
428 len--;
429 p--;
430 }
Bhaskar98634f02013-10-29 23:30:51 -0400431 hash = gen_hash(px, start, (end - start));
Benoitaffb4812009-03-25 13:02:10 +0100432 }
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500433 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100434 hash = full_hash(hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200435 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200436 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
437 return chash_get_server_hash(px, hash);
438 else
439 return map_get_server_hash(px, hash);
Benoitaffb4812009-03-25 13:02:10 +0100440}
441
Willy Tarreau34db1082012-04-19 17:16:54 +0200442/* RDP Cookie HASH. */
Emeric Brun736aa232009-06-30 17:56:00 +0200443struct server *get_server_rch(struct session *s)
444{
445 unsigned long hash = 0;
446 struct proxy *px = s->be;
447 unsigned long len;
Emeric Brun736aa232009-06-30 17:56:00 +0200448 int ret;
Willy Tarreau37406352012-04-23 16:16:37 +0200449 struct sample smp;
Willy Tarreaud1de8af2012-05-18 22:12:14 +0200450 int rewind;
Emeric Brun736aa232009-06-30 17:56:00 +0200451
452 /* tot_weight appears to mean srv_count */
453 if (px->lbprm.tot_weight == 0)
454 return NULL;
455
Willy Tarreau37406352012-04-23 16:16:37 +0200456 memset(&smp, 0, sizeof(smp));
Emeric Brun736aa232009-06-30 17:56:00 +0200457
Willy Tarreau9b28e032012-10-12 23:49:43 +0200458 b_rew(s->req->buf, rewind = s->req->buf->o);
Willy Tarreaud1de8af2012-05-18 22:12:14 +0200459
Willy Tarreaucadd8c92013-07-22 18:09:52 +0200460 ret = fetch_rdp_cookie_name(s, &smp, px->hh_name, px->hh_len);
Willy Tarreauf853c462012-04-23 18:53:56 +0200461 len = smp.data.str.len;
Willy Tarreau664092c2011-12-16 19:11:42 +0100462
Willy Tarreau9b28e032012-10-12 23:49:43 +0200463 b_adv(s->req->buf, rewind);
Willy Tarreaud1de8af2012-05-18 22:12:14 +0200464
Willy Tarreau37406352012-04-23 16:16:37 +0200465 if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || len == 0)
Emeric Brun736aa232009-06-30 17:56:00 +0200466 return NULL;
467
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200468 /* note: we won't hash if there's only one server left */
469 if (px->lbprm.tot_used == 1)
470 goto hash_done;
471
Emeric Brun736aa232009-06-30 17:56:00 +0200472 /* Found a the hh_name in the headers.
473 * we will compute the hash based on this value ctx.val.
474 */
Bhaskar98634f02013-10-29 23:30:51 -0400475 hash = gen_hash(px, smp.data.str.str, len);
476
Bhaskar Maddalab6c0ac92013-11-05 11:54:02 -0500477 if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
Willy Tarreau798a39c2010-11-24 15:04:29 +0100478 hash = full_hash(hash);
Willy Tarreau39c9ba72009-10-01 21:11:15 +0200479 hash_done:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200480 if (px->lbprm.algo & BE_LB_LKUP_CHTREE)
481 return chash_get_server_hash(px, hash);
482 else
483 return map_get_server_hash(px, hash);
Emeric Brun736aa232009-06-30 17:56:00 +0200484}
Benoitaffb4812009-03-25 13:02:10 +0100485
486/*
Willy Tarreau7c669d72008-06-20 15:04:11 +0200487 * This function applies the load-balancing algorithm to the session, as
488 * defined by the backend it is assigned to. The session is then marked as
489 * 'assigned'.
490 *
491 * This function MAY NOT be called with SN_ASSIGNED already set. If the session
492 * had a server previously assigned, it is rebalanced, trying to avoid the same
Willy Tarreau827aee92011-03-10 16:55:02 +0100493 * server, which should still be present in target_srv(&s->target) before the call.
Willy Tarreau7c669d72008-06-20 15:04:11 +0200494 * The function tries to keep the original connection slot if it reconnects to
495 * the same server, otherwise it releases it and tries to offer it.
496 *
497 * It is illegal to call this function with a session in a queue.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200498 *
499 * It may return :
Willy Tarreau664beb82011-03-10 11:38:29 +0100500 * SRV_STATUS_OK if everything is OK. ->srv and ->target are assigned.
Willy Tarreau7c669d72008-06-20 15:04:11 +0200501 * SRV_STATUS_NOSRV if no server is available. Session is not ASSIGNED
502 * SRV_STATUS_FULL if all servers are saturated. Session is not ASSIGNED
Willy Tarreaubaaee002006-06-26 02:48:02 +0200503 * SRV_STATUS_INTERNAL for other unrecoverable errors.
504 *
Willy Tarreau7c669d72008-06-20 15:04:11 +0200505 * Upon successful return, the session flag SN_ASSIGNED is set to indicate that
Willy Tarreau827aee92011-03-10 16:55:02 +0100506 * it does not need to be called anymore. This means that target_srv(&s->target)
507 * can be trusted in balance and direct modes.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200508 *
509 */
510
511int assign_server(struct session *s)
512{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200513 struct connection *conn;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200514 struct server *conn_slot;
Willy Tarreau827aee92011-03-10 16:55:02 +0100515 struct server *srv, *prev_srv;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200516 int err;
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100517
Simon Horman8effd3d2011-08-13 08:03:52 +0900518 DPRINTF(stderr,"assign_server : s=%p\n",s);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200519
Willy Tarreau7c669d72008-06-20 15:04:11 +0200520 err = SRV_STATUS_INTERNAL;
521 if (unlikely(s->pend_pos || s->flags & SN_ASSIGNED))
522 goto out_err;
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100523
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100524 prev_srv = objt_server(s->target);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200525 conn_slot = s->srv_conn;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200526
Willy Tarreau7c669d72008-06-20 15:04:11 +0200527 /* We have to release any connection slot before applying any LB algo,
528 * otherwise we may erroneously end up with no available slot.
529 */
530 if (conn_slot)
531 sess_change_server(s, NULL);
532
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100533 /* We will now try to find the good server and store it into <objt_server(s->target)>.
534 * Note that <objt_server(s->target)> may be NULL in case of dispatch or proxy mode,
Willy Tarreau7c669d72008-06-20 15:04:11 +0200535 * as well as if no server is available (check error code).
536 */
Willy Tarreau1a20a5d2007-11-01 21:08:19 +0100537
Willy Tarreau827aee92011-03-10 16:55:02 +0100538 srv = NULL;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100539 s->target = NULL;
Willy Tarreau9420b122013-12-15 18:58:25 +0100540 conn = objt_conn(s->req->cons->end);
Willy Tarreau664beb82011-03-10 11:38:29 +0100541
Willy Tarreau068621e2013-12-23 15:11:25 +0100542 if (conn &&
Willy Tarreau2481d162014-02-19 18:40:43 +0100543 (conn->flags & CO_FL_CONNECTED) &&
Willy Tarreau068621e2013-12-23 15:11:25 +0100544 ((s->be->options & PR_O_PREF_LAST) || (s->txn.flags & TX_PREFER_LAST)) &&
Willy Tarreau9420b122013-12-15 18:58:25 +0100545 objt_server(conn->target) && __objt_server(conn->target)->proxy == s->be &&
546 srv_is_usable(__objt_server(conn->target)->state, __objt_server(conn->target)->eweight)) {
547 /* This session was relying on a server in a previous request
548 * and the proxy has "option prefer-current-server" set, so
549 * let's try to reuse the same server.
550 */
551 srv = __objt_server(conn->target);
552 s->target = &srv->obj_type;
553 }
554 else if (s->be->lbprm.algo & BE_LB_KIND) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200555 /* we must check if we have at least one server available */
556 if (!s->be->lbprm.tot_weight) {
557 err = SRV_STATUS_NOSRV;
558 goto out;
559 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200560
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200561 /* First check whether we need to fetch some data or simply call
562 * the LB lookup function. Only the hashing functions will need
563 * some input data in fact, and will support multiple algorithms.
564 */
565 switch (s->be->lbprm.algo & BE_LB_LKUP) {
566 case BE_LB_LKUP_RRTREE:
Willy Tarreau827aee92011-03-10 16:55:02 +0100567 srv = fwrr_get_next_server(s->be, prev_srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200568 break;
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200569
Willy Tarreauf09c6602012-02-13 17:12:08 +0100570 case BE_LB_LKUP_FSTREE:
571 srv = fas_get_next_server(s->be, prev_srv);
572 break;
573
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200574 case BE_LB_LKUP_LCTREE:
Willy Tarreau827aee92011-03-10 16:55:02 +0100575 srv = fwlc_get_next_server(s->be, prev_srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200576 break;
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200577
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200578 case BE_LB_LKUP_CHTREE:
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200579 case BE_LB_LKUP_MAP:
Willy Tarreau9757a382009-10-03 12:56:50 +0200580 if ((s->be->lbprm.algo & BE_LB_KIND) == BE_LB_KIND_RR) {
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200581 if (s->be->lbprm.algo & BE_LB_LKUP_CHTREE)
Willy Tarreau827aee92011-03-10 16:55:02 +0100582 srv = chash_get_next_server(s->be, prev_srv);
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200583 else
Willy Tarreau827aee92011-03-10 16:55:02 +0100584 srv = map_get_server_rr(s->be, prev_srv);
Willy Tarreau9757a382009-10-03 12:56:50 +0200585 break;
586 }
587 else if ((s->be->lbprm.algo & BE_LB_KIND) != BE_LB_KIND_HI) {
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200588 /* unknown balancing algorithm */
Willy Tarreau7c669d72008-06-20 15:04:11 +0200589 err = SRV_STATUS_INTERNAL;
590 goto out;
591 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200592
593 switch (s->be->lbprm.algo & BE_LB_PARM) {
594 case BE_LB_HASH_SRC:
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200595 conn = objt_conn(s->req->prod->end);
596 if (conn && conn->addr.from.ss_family == AF_INET) {
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200597 srv = get_server_sh(s->be,
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200598 (void *)&((struct sockaddr_in *)&conn->addr.from)->sin_addr,
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200599 4);
600 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200601 else if (conn && conn->addr.from.ss_family == AF_INET6) {
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200602 srv = get_server_sh(s->be,
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200603 (void *)&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr,
Willy Tarreau5dd7fa12012-03-31 19:53:37 +0200604 16);
605 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200606 else {
607 /* unknown IP family */
608 err = SRV_STATUS_INTERNAL;
609 goto out;
610 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200611 break;
612
613 case BE_LB_HASH_URI:
614 /* URI hashing */
Willy Tarreaueaed5a12010-03-24 14:54:30 +0100615 if (s->txn.req.msg_state < HTTP_MSG_BODY)
616 break;
Willy Tarreau827aee92011-03-10 16:55:02 +0100617 srv = get_server_uh(s->be,
Willy Tarreauda6eed62014-04-17 20:24:24 +0200618 b_ptr(s->req->buf, -http_uri_rewind(&s->txn.req)),
Willy Tarreau827aee92011-03-10 16:55:02 +0100619 s->txn.req.sl.rq.u_l);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200620 break;
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200621
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200622 case BE_LB_HASH_PRM:
623 /* URL Parameter hashing */
Willy Tarreaueaed5a12010-03-24 14:54:30 +0100624 if (s->txn.req.msg_state < HTTP_MSG_BODY)
625 break;
Willy Tarreau61a21a32011-03-01 20:35:49 +0100626
Willy Tarreau827aee92011-03-10 16:55:02 +0100627 srv = get_server_ph(s->be,
Willy Tarreauda6eed62014-04-17 20:24:24 +0200628 b_ptr(s->req->buf, -http_uri_rewind(&s->txn.req)),
Willy Tarreau827aee92011-03-10 16:55:02 +0100629 s->txn.req.sl.rq.u_l);
Willy Tarreau61a21a32011-03-01 20:35:49 +0100630
Willy Tarreau827aee92011-03-10 16:55:02 +0100631 if (!srv && s->txn.meth == HTTP_METH_POST)
632 srv = get_server_ph_post(s);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200633 break;
Benoitaffb4812009-03-25 13:02:10 +0100634
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200635 case BE_LB_HASH_HDR:
636 /* Header Parameter hashing */
Willy Tarreaueaed5a12010-03-24 14:54:30 +0100637 if (s->txn.req.msg_state < HTTP_MSG_BODY)
638 break;
Willy Tarreau827aee92011-03-10 16:55:02 +0100639 srv = get_server_hh(s);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200640 break;
641
642 case BE_LB_HASH_RDP:
643 /* RDP Cookie hashing */
Willy Tarreau827aee92011-03-10 16:55:02 +0100644 srv = get_server_rch(s);
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200645 break;
646
647 default:
648 /* unknown balancing algorithm */
649 err = SRV_STATUS_INTERNAL;
650 goto out;
Benoitaffb4812009-03-25 13:02:10 +0100651 }
Emeric Brun736aa232009-06-30 17:56:00 +0200652
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200653 /* If the hashing parameter was not found, let's fall
654 * back to round robin on the map.
655 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100656 if (!srv) {
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200657 if (s->be->lbprm.algo & BE_LB_LKUP_CHTREE)
Willy Tarreau827aee92011-03-10 16:55:02 +0100658 srv = chash_get_next_server(s->be, prev_srv);
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200659 else
Willy Tarreau827aee92011-03-10 16:55:02 +0100660 srv = map_get_server_rr(s->be, prev_srv);
Willy Tarreau6b2e11b2009-10-01 07:52:15 +0200661 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200662
663 /* end of map-based LB */
Emeric Brun736aa232009-06-30 17:56:00 +0200664 break;
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200665
Willy Tarreau7c669d72008-06-20 15:04:11 +0200666 default:
667 /* unknown balancing algorithm */
668 err = SRV_STATUS_INTERNAL;
669 goto out;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200670 }
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200671
Willy Tarreau827aee92011-03-10 16:55:02 +0100672 if (!srv) {
Willy Tarreauda76f4f2009-10-03 12:36:05 +0200673 err = SRV_STATUS_FULL;
674 goto out;
675 }
Willy Tarreau827aee92011-03-10 16:55:02 +0100676 else if (srv != prev_srv) {
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -0500677 be_set_sess_last(s->be);
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100678 s->be->be_counters.cum_lbconn++;
Willy Tarreau827aee92011-03-10 16:55:02 +0100679 srv->counters.cum_lbconn++;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100680 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100681 s->target = &srv->obj_type;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200682 }
Willy Tarreau1620ec32011-08-06 17:05:02 +0200683 else if (s->be->options & (PR_O_DISPATCH | PR_O_TRANSP)) {
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100684 s->target = &s->be->obj_type;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200685 }
David du Colombier6f5ccb12011-03-10 22:26:24 +0100686 else if ((s->be->options & PR_O_HTTP_PROXY) &&
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200687 (conn = objt_conn(s->req->cons->end)) &&
688 is_addr(&conn->addr.to)) {
Willy Tarreau664beb82011-03-10 11:38:29 +0100689 /* in proxy mode, we need a valid destination address */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100690 s->target = &s->be->obj_type;
Willy Tarreau664beb82011-03-10 11:38:29 +0100691 }
692 else {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200693 err = SRV_STATUS_NOSRV;
694 goto out;
695 }
696
697 s->flags |= SN_ASSIGNED;
698 err = SRV_STATUS_OK;
699 out:
700
701 /* Either we take back our connection slot, or we offer it to someone
702 * else if we don't need it anymore.
703 */
704 if (conn_slot) {
Willy Tarreau827aee92011-03-10 16:55:02 +0100705 if (conn_slot == srv) {
706 sess_change_server(s, srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200707 } else {
708 if (may_dequeue_tasks(conn_slot, s->be))
709 process_srv_queue(conn_slot);
710 }
711 }
712
713 out_err:
714 return err;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200715}
716
717
718/*
719 * This function assigns a server address to a session, and sets SN_ADDR_SET.
720 * The address is taken from the currently assigned server, or from the
721 * dispatch or transparent address.
722 *
723 * It may return :
724 * SRV_STATUS_OK if everything is OK.
725 * SRV_STATUS_INTERNAL for other unrecoverable errors.
726 *
727 * Upon successful return, the session flag SN_ADDR_SET is set. This flag is
728 * not cleared, so it's to the caller to clear it if required.
729 *
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200730 * The caller is responsible for having already assigned a connection
731 * to si->end.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200732 *
Willy Tarreaubaaee002006-06-26 02:48:02 +0200733 */
734int assign_server_address(struct session *s)
735{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200736 struct connection *cli_conn = objt_conn(s->req->prod->end);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200737 struct connection *srv_conn = objt_conn(s->req->cons->end);
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200738
Willy Tarreaubaaee002006-06-26 02:48:02 +0200739#ifdef DEBUG_FULL
740 fprintf(stderr,"assign_server_address : s=%p\n",s);
741#endif
742
Willy Tarreauf3e49f92009-10-03 12:21:20 +0200743 if ((s->flags & SN_DIRECT) || (s->be->lbprm.algo & BE_LB_KIND)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200744 /* A server is necessarily known for this session */
745 if (!(s->flags & SN_ASSIGNED))
746 return SRV_STATUS_INTERNAL;
747
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200748 srv_conn->addr.to = objt_server(s->target)->addr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200749
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200750 if (!is_addr(&srv_conn->addr.to) && cli_conn) {
Willy Tarreaud669a4f2010-07-13 14:49:50 +0200751 /* if the server has no address, we use the same address
752 * the client asked, which is handy for remapping ports
753 * locally on multiple addresses at once.
754 */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200755 conn_get_to_addr(cli_conn);
Willy Tarreaud669a4f2010-07-13 14:49:50 +0200756
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200757 if (cli_conn->addr.to.ss_family == AF_INET) {
758 ((struct sockaddr_in *)&srv_conn->addr.to)->sin_addr = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
759 } else if (cli_conn->addr.to.ss_family == AF_INET6) {
760 ((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 +0200761 }
Willy Tarreaud669a4f2010-07-13 14:49:50 +0200762 }
763
Willy Tarreaubaaee002006-06-26 02:48:02 +0200764 /* if this server remaps proxied ports, we'll use
765 * the port the client connected to with an offset. */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200766 if ((objt_server(s->target)->state & SRV_MAPPORTS) && cli_conn) {
David du Colombier6f5ccb12011-03-10 22:26:24 +0100767 int base_port;
768
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200769 conn_get_to_addr(cli_conn);
David du Colombier6f5ccb12011-03-10 22:26:24 +0100770
771 /* First, retrieve the port from the incoming connection */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200772 base_port = get_host_port(&cli_conn->addr.to);
David du Colombier6f5ccb12011-03-10 22:26:24 +0100773
774 /* Second, assign the outgoing connection's port */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200775 base_port += get_host_port(&srv_conn->addr.to);
776 set_host_port(&srv_conn->addr.to, base_port);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200777 }
778 }
Willy Tarreau1620ec32011-08-06 17:05:02 +0200779 else if (s->be->options & PR_O_DISPATCH) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200780 /* connect to the defined dispatch addr */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200781 srv_conn->addr.to = s->be->dispatch_addr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200782 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200783 else if ((s->be->options & PR_O_TRANSP) && cli_conn) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200784 /* in transparent mode, use the original dest addr if no dispatch specified */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200785 conn_get_to_addr(cli_conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200786
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200787 if (cli_conn->addr.to.ss_family == AF_INET || cli_conn->addr.to.ss_family == AF_INET6)
788 srv_conn->addr.to = cli_conn->addr.to;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200789 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100790 else if (s->be->options & PR_O_HTTP_PROXY) {
791 /* If HTTP PROXY option is set, then server is already assigned
792 * during incoming client request parsing. */
793 }
Willy Tarreau1a1158b2007-01-20 11:07:46 +0100794 else {
795 /* no server and no LB algorithm ! */
796 return SRV_STATUS_INTERNAL;
797 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200798
799 s->flags |= SN_ADDR_SET;
800 return SRV_STATUS_OK;
801}
802
803
804/* This function assigns a server to session <s> if required, and can add the
805 * connection to either the assigned server's queue or to the proxy's queue.
Willy Tarreau7c669d72008-06-20 15:04:11 +0200806 * If ->srv_conn is set, the session is first released from the server.
807 * It may also be called with SN_DIRECT and/or SN_ASSIGNED though. It will
808 * be called before any connection and after any retry or redispatch occurs.
809 *
810 * It is not allowed to call this function with a session in a queue.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200811 *
812 * Returns :
813 *
814 * SRV_STATUS_OK if everything is OK.
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100815 * SRV_STATUS_NOSRV if no server is available. objt_server(s->target) = NULL.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200816 * SRV_STATUS_QUEUED if the connection has been queued.
817 * SRV_STATUS_FULL if the server(s) is/are saturated and the
Willy Tarreau827aee92011-03-10 16:55:02 +0100818 * connection could not be queued at the server's,
Willy Tarreau7c669d72008-06-20 15:04:11 +0200819 * which may be NULL if we queue on the backend.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200820 * SRV_STATUS_INTERNAL for other unrecoverable errors.
821 *
822 */
823int assign_server_and_queue(struct session *s)
824{
825 struct pendconn *p;
Willy Tarreau827aee92011-03-10 16:55:02 +0100826 struct server *srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200827 int err;
828
829 if (s->pend_pos)
830 return SRV_STATUS_INTERNAL;
831
Willy Tarreau7c669d72008-06-20 15:04:11 +0200832 err = SRV_STATUS_OK;
833 if (!(s->flags & SN_ASSIGNED)) {
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100834 struct server *prev_srv = objt_server(s->target);
Willy Tarreau3d80d912011-03-10 11:42:13 +0100835
Willy Tarreau7c669d72008-06-20 15:04:11 +0200836 err = assign_server(s);
Willy Tarreau3d80d912011-03-10 11:42:13 +0100837 if (prev_srv) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200838 /* This session was previously assigned to a server. We have to
839 * update the session's and the server's stats :
840 * - if the server changed :
841 * - set TX_CK_DOWN if txn.flags was TX_CK_VALID
842 * - set SN_REDISP if it was successfully redispatched
843 * - increment srv->redispatches and be->redispatches
844 * - if the server remained the same : update retries.
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100845 */
846
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100847 if (prev_srv != objt_server(s->target)) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200848 if ((s->txn.flags & TX_CK_MASK) == TX_CK_VALID) {
849 s->txn.flags &= ~TX_CK_MASK;
850 s->txn.flags |= TX_CK_DOWN;
851 }
852 s->flags |= SN_REDISP;
Willy Tarreau3d80d912011-03-10 11:42:13 +0100853 prev_srv->counters.redispatches++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100854 s->be->be_counters.redispatches++;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200855 } else {
Willy Tarreau3d80d912011-03-10 11:42:13 +0100856 prev_srv->counters.retries++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100857 s->be->be_counters.retries++;
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100858 }
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +0100859 }
860 }
861
Willy Tarreaubaaee002006-06-26 02:48:02 +0200862 switch (err) {
863 case SRV_STATUS_OK:
Willy Tarreau7c669d72008-06-20 15:04:11 +0200864 /* we have SN_ASSIGNED set */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100865 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +0100866 if (!srv)
Willy Tarreau7c669d72008-06-20 15:04:11 +0200867 return SRV_STATUS_OK; /* dispatch or proxy mode */
868
869 /* If we already have a connection slot, no need to check any queue */
Willy Tarreau827aee92011-03-10 16:55:02 +0100870 if (s->srv_conn == srv)
Willy Tarreau7c669d72008-06-20 15:04:11 +0200871 return SRV_STATUS_OK;
872
873 /* OK, this session already has an assigned server, but no
874 * connection slot yet. Either it is a redispatch, or it was
875 * assigned from persistence information (direct mode).
876 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100877 if ((s->flags & SN_REDIRECTABLE) && srv->rdr_len) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200878 /* server scheduled for redirection, and already assigned. We
879 * don't want to go further nor check the queue.
Willy Tarreau21d2af32008-02-14 20:25:24 +0100880 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100881 sess_change_server(s, srv); /* not really needed in fact */
Willy Tarreau21d2af32008-02-14 20:25:24 +0100882 return SRV_STATUS_OK;
883 }
884
Willy Tarreau7c669d72008-06-20 15:04:11 +0200885 /* We might have to queue this session if the assigned server is full.
886 * We know we have to queue it into the server's queue, so if a maxqueue
887 * is set on the server, we must also check that the server's queue is
888 * not full, in which case we have to return FULL.
889 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100890 if (srv->maxconn &&
891 (srv->nbpend || srv->served >= srv_dynamic_maxconn(srv))) {
Willy Tarreau7c669d72008-06-20 15:04:11 +0200892
Willy Tarreau827aee92011-03-10 16:55:02 +0100893 if (srv->maxqueue > 0 && srv->nbpend >= srv->maxqueue)
Willy Tarreau7c669d72008-06-20 15:04:11 +0200894 return SRV_STATUS_FULL;
895
Willy Tarreaubaaee002006-06-26 02:48:02 +0200896 p = pendconn_add(s);
897 if (p)
898 return SRV_STATUS_QUEUED;
899 else
Willy Tarreau7c669d72008-06-20 15:04:11 +0200900 return SRV_STATUS_INTERNAL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200901 }
Willy Tarreau7c669d72008-06-20 15:04:11 +0200902
903 /* OK, we can use this server. Let's reserve our place */
Willy Tarreau827aee92011-03-10 16:55:02 +0100904 sess_change_server(s, srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200905 return SRV_STATUS_OK;
906
907 case SRV_STATUS_FULL:
908 /* queue this session into the proxy's queue */
909 p = pendconn_add(s);
910 if (p)
911 return SRV_STATUS_QUEUED;
912 else
Willy Tarreau7c669d72008-06-20 15:04:11 +0200913 return SRV_STATUS_INTERNAL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200914
915 case SRV_STATUS_NOSRV:
Willy Tarreau7c669d72008-06-20 15:04:11 +0200916 return err;
917
Willy Tarreaubaaee002006-06-26 02:48:02 +0200918 case SRV_STATUS_INTERNAL:
919 return err;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200920
Willy Tarreaubaaee002006-06-26 02:48:02 +0200921 default:
922 return SRV_STATUS_INTERNAL;
923 }
Willy Tarreau5b6995c2008-01-13 16:31:17 +0100924}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200925
Willy Tarreaub1d67742010-03-29 19:36:59 +0200926/* If an explicit source binding is specified on the server and/or backend, and
927 * this source makes use of the transparent proxy, then it is extracted now and
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200928 * assigned to the session's pending connection. This function assumes that an
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200929 * outgoing connection has already been assigned to s->req->cons->end.
Willy Tarreaub1d67742010-03-29 19:36:59 +0200930 */
931static void assign_tproxy_address(struct session *s)
932{
Pieter Baauwd551fb52013-05-08 22:49:23 +0200933#if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100934 struct server *srv = objt_server(s->target);
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100935 struct conn_src *src;
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200936 struct connection *cli_conn;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200937 struct connection *srv_conn = objt_conn(s->req->cons->end);
Willy Tarreau827aee92011-03-10 16:55:02 +0100938
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100939 if (srv && srv->conn_src.opts & CO_SRC_BIND)
940 src = &srv->conn_src;
941 else if (s->be->conn_src.opts & CO_SRC_BIND)
942 src = &s->be->conn_src;
943 else
944 return;
Willy Tarreau294c4732011-12-16 21:35:50 +0100945
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100946 switch (src->opts & CO_SRC_TPROXY_MASK) {
947 case CO_SRC_TPROXY_ADDR:
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200948 srv_conn->addr.from = src->tproxy_addr;
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100949 break;
950 case CO_SRC_TPROXY_CLI:
951 case CO_SRC_TPROXY_CIP:
952 /* FIXME: what can we do if the client connects in IPv6 or unix socket ? */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200953 cli_conn = objt_conn(s->req->prod->end);
954 if (cli_conn)
955 srv_conn->addr.from = cli_conn->addr.from;
956 else
957 memset(&srv_conn->addr.from, 0, sizeof(srv_conn->addr.from));
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100958 break;
959 case CO_SRC_TPROXY_DYN:
960 if (src->bind_hdr_occ) {
961 char *vptr;
962 int vlen;
963 int rewind;
Willy Tarreau294c4732011-12-16 21:35:50 +0100964
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100965 /* bind to the IP in a header */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200966 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_family = AF_INET;
967 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_port = 0;
968 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_addr.s_addr = 0;
Willy Tarreau294c4732011-12-16 21:35:50 +0100969
Willy Tarreau211cdec2014-04-17 20:18:08 +0200970 b_rew(s->req->buf, rewind = http_hdr_rewind(&s->txn.req));
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100971 if (http_get_hdr(&s->txn.req, src->bind_hdr_name, src->bind_hdr_len,
972 &s->txn.hdr_idx, src->bind_hdr_occ, NULL, &vptr, &vlen)) {
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200973 ((struct sockaddr_in *)&srv_conn->addr.from)->sin_addr.s_addr =
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100974 htonl(inetaddr_host_lim(vptr, vptr + vlen));
Willy Tarreaubce70882009-09-07 11:51:47 +0200975 }
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100976 b_adv(s->req->buf, rewind);
Willy Tarreaub1d67742010-03-29 19:36:59 +0200977 }
Willy Tarreau9cd7d6c2012-12-08 23:13:33 +0100978 break;
979 default:
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200980 memset(&srv_conn->addr.from, 0, sizeof(srv_conn->addr.from));
Willy Tarreaub1d67742010-03-29 19:36:59 +0200981 }
982#endif
983}
984
985
Willy Tarreaubaaee002006-06-26 02:48:02 +0200986/*
987 * This function initiates a connection to the server assigned to this session
Willy Tarreau6471afb2011-09-23 10:54:59 +0200988 * (s->target, s->req->cons->addr.to). It will assign a server if none
Willy Tarreau664beb82011-03-10 11:38:29 +0100989 * is assigned yet.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200990 * It can return one of :
991 * - SN_ERR_NONE if everything's OK
992 * - SN_ERR_SRVTO if there are no more servers
993 * - SN_ERR_SRVCL if the connection was refused by the server
994 * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
995 * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
996 * - SN_ERR_INTERNAL for any other purely internal errors
997 * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200998 * The server-facing stream interface is expected to hold a pre-allocated connection
999 * in s->req->cons->conn.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001000 */
1001int connect_server(struct session *s)
1002{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001003 struct connection *cli_conn;
Willy Tarreau34601a82013-12-15 16:33:46 +01001004 struct connection *srv_conn;
Willy Tarreau827aee92011-03-10 16:55:02 +01001005 struct server *srv;
Willy Tarreau34601a82013-12-15 16:33:46 +01001006 int reuse = 0;
Willy Tarreau9650f372009-08-16 14:02:45 +02001007 int err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001008
Willy Tarreau34601a82013-12-15 16:33:46 +01001009 srv_conn = objt_conn(s->req->cons->end);
1010 if (srv_conn)
1011 reuse = s->target == srv_conn->target;
1012
1013 if (reuse) {
1014 /* Disable connection reuse if a dynamic source is used.
1015 * As long as we don't share connections between servers,
1016 * we don't need to disable connection reuse on no-idempotent
1017 * requests nor when PROXY protocol is used.
1018 */
1019 srv = objt_server(s->target);
1020 if (srv && srv->conn_src.opts & CO_SRC_BIND) {
1021 if ((srv->conn_src.opts & CO_SRC_TPROXY_MASK) == CO_SRC_TPROXY_DYN)
1022 reuse = 0;
1023 }
1024 else if (s->be->conn_src.opts & CO_SRC_BIND) {
1025 if ((s->be->conn_src.opts & CO_SRC_TPROXY_MASK) == CO_SRC_TPROXY_DYN)
1026 reuse = 0;
1027 }
1028 }
1029
1030 srv_conn = si_alloc_conn(s->req->cons, reuse);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02001031 if (!srv_conn)
1032 return SN_ERR_RESOURCE;
1033
Willy Tarreaubaaee002006-06-26 02:48:02 +02001034 if (!(s->flags & SN_ADDR_SET)) {
1035 err = assign_server_address(s);
1036 if (err != SRV_STATUS_OK)
1037 return SN_ERR_INTERNAL;
1038 }
1039
Willy Tarreauff605db2013-12-20 11:09:51 +01001040 if (!conn_xprt_ready(srv_conn)) {
1041 /* the target was only on the session, assign it to the SI now */
1042 srv_conn->target = s->target;
Willy Tarreaud88edf22009-06-14 15:48:17 +02001043
Willy Tarreauff605db2013-12-20 11:09:51 +01001044 /* set the correct protocol on the output stream interface */
1045 if (objt_server(s->target)) {
1046 conn_prepare(srv_conn, objt_server(s->target)->proto, objt_server(s->target)->xprt);
1047 }
1048 else if (obj_type(s->target) == OBJ_TYPE_PROXY) {
1049 /* proxies exclusively run on raw_sock right now */
1050 conn_prepare(srv_conn, protocol_by_family(srv_conn->addr.to.ss_family), &raw_sock);
1051 if (!objt_conn(s->req->cons->end) || !objt_conn(s->req->cons->end)->ctrl)
1052 return SN_ERR_INTERNAL;
1053 }
1054 else
1055 return SN_ERR_INTERNAL; /* how did we get there ? */
Willy Tarreaud02394b2012-05-11 18:32:18 +02001056
Willy Tarreauff605db2013-12-20 11:09:51 +01001057 /* process the case where the server requires the PROXY protocol to be sent */
1058 srv_conn->send_proxy_ofs = 0;
1059 if (objt_server(s->target) && (objt_server(s->target)->state & SRV_SEND_PROXY)) {
1060 srv_conn->send_proxy_ofs = 1; /* must compute size */
1061 cli_conn = objt_conn(s->req->prod->end);
1062 if (cli_conn)
1063 conn_get_to_addr(cli_conn);
1064 }
Willy Tarreau2a6e8802013-10-24 15:50:53 +02001065
Willy Tarreauff605db2013-12-20 11:09:51 +01001066 si_attach_conn(s->req->cons, srv_conn);
Willy Tarreau26d8c592012-05-07 18:12:14 +02001067
Willy Tarreauff605db2013-12-20 11:09:51 +01001068 assign_tproxy_address(s);
1069 }
1070 else {
1071 /* the connection is being reused, just re-attach it */
1072 si_attach_conn(s->req->cons, srv_conn);
Willy Tarreau36346242014-02-24 18:26:30 +01001073 s->flags |= SN_SRV_REUSED;
Willy Tarreauff605db2013-12-20 11:09:51 +01001074 }
Willy Tarreaub1d67742010-03-29 19:36:59 +02001075
William Lallemandb7ff6a32012-03-02 14:35:21 +01001076 /* flag for logging source ip/port */
1077 if (s->fe->options2 & PR_O2_SRC_ADDR)
1078 s->req->cons->flags |= SI_FL_SRC_ADDR;
1079
Willy Tarreau14f8e862012-08-30 22:23:13 +02001080 /* disable lingering */
1081 if (s->be->options & PR_O_TCP_NOLING)
1082 s->req->cons->flags |= SI_FL_NOLINGER;
1083
Willy Tarreau73b013b2012-05-21 16:31:45 +02001084 err = si_connect(s->req->cons);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001085
Willy Tarreau9650f372009-08-16 14:02:45 +02001086 if (err != SN_ERR_NONE)
1087 return err;
Willy Tarreau788e2842008-08-26 13:25:39 +02001088
Willy Tarreau14f8e862012-08-30 22:23:13 +02001089 /* set connect timeout */
1090 s->req->cons->exp = tick_add_ifset(now_ms, s->be->timeout.connect);
1091
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001092 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001093 if (srv) {
Willy Tarreau1e62de62008-11-11 20:20:02 +01001094 s->flags |= SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +01001095 srv->cur_sess++;
1096 if (srv->cur_sess > srv->counters.cur_sess_max)
1097 srv->counters.cur_sess_max = srv->cur_sess;
Willy Tarreau51406232008-03-10 22:04:20 +01001098 if (s->be->lbprm.server_take_conn)
Willy Tarreau827aee92011-03-10 16:55:02 +01001099 s->be->lbprm.server_take_conn(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001100 }
1101
Willy Tarreaubaaee002006-06-26 02:48:02 +02001102 return SN_ERR_NONE; /* connection is OK */
1103}
1104
1105
Willy Tarreaubaaee002006-06-26 02:48:02 +02001106/* This function performs the "redispatch" part of a connection attempt. It
1107 * will assign a server if required, queue the connection if required, and
1108 * handle errors that might arise at this level. It can change the server
1109 * state. It will return 1 if it encounters an error, switches the server
1110 * state, or has to queue a connection. Otherwise, it will return 0 indicating
1111 * that the connection is ready to use.
1112 */
1113
1114int srv_redispatch_connect(struct session *t)
1115{
Willy Tarreau827aee92011-03-10 16:55:02 +01001116 struct server *srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001117 int conn_err;
1118
1119 /* We know that we don't have any connection pending, so we will
1120 * try to get a new one, and wait in this state if it's queued
1121 */
Willy Tarreau7c669d72008-06-20 15:04:11 +02001122 redispatch:
Willy Tarreaubaaee002006-06-26 02:48:02 +02001123 conn_err = assign_server_and_queue(t);
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001124 srv = objt_server(t->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001125
Willy Tarreaubaaee002006-06-26 02:48:02 +02001126 switch (conn_err) {
1127 case SRV_STATUS_OK:
1128 break;
1129
Willy Tarreau7c669d72008-06-20 15:04:11 +02001130 case SRV_STATUS_FULL:
1131 /* The server has reached its maxqueue limit. Either PR_O_REDISP is set
1132 * and we can redispatch to another server, or it is not and we return
1133 * 503. This only makes sense in DIRECT mode however, because normal LB
1134 * algorithms would never select such a server, and hash algorithms
Willy Tarreau827aee92011-03-10 16:55:02 +01001135 * would bring us on the same server again. Note that t->target is set
1136 * in this case.
Willy Tarreau7c669d72008-06-20 15:04:11 +02001137 */
Willy Tarreau4de91492010-01-22 19:10:05 +01001138 if (((t->flags & (SN_DIRECT|SN_FORCE_PRST)) == SN_DIRECT) &&
1139 (t->be->options & PR_O_REDISP)) {
Willy Tarreau7c669d72008-06-20 15:04:11 +02001140 t->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Willy Tarreau7c669d72008-06-20 15:04:11 +02001141 goto redispatch;
1142 }
1143
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001144 if (!t->req->cons->err_type) {
1145 t->req->cons->err_type = SI_ET_QUEUE_ERR;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001146 }
Willy Tarreau7c669d72008-06-20 15:04:11 +02001147
Willy Tarreau827aee92011-03-10 16:55:02 +01001148 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001149 t->be->be_counters.failed_conns++;
Willy Tarreau7c669d72008-06-20 15:04:11 +02001150 return 1;
1151
Willy Tarreaubaaee002006-06-26 02:48:02 +02001152 case SRV_STATUS_NOSRV:
Willy Tarreau827aee92011-03-10 16:55:02 +01001153 /* note: it is guaranteed that srv == NULL here */
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001154 if (!t->req->cons->err_type) {
1155 t->req->cons->err_type = SI_ET_CONN_ERR;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001156 }
Krzysztof Piotr Oledzki5a329cf2008-02-22 03:50:19 +01001157
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001158 t->be->be_counters.failed_conns++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001159 return 1;
1160
1161 case SRV_STATUS_QUEUED:
Willy Tarreau35374672008-09-03 18:11:02 +02001162 t->req->cons->exp = tick_add_ifset(now_ms, t->be->timeout.queue);
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001163 t->req->cons->state = SI_ST_QUE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001164 /* do nothing else and do not wake any other session up */
1165 return 1;
1166
Willy Tarreaubaaee002006-06-26 02:48:02 +02001167 case SRV_STATUS_INTERNAL:
1168 default:
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001169 if (!t->req->cons->err_type) {
1170 t->req->cons->err_type = SI_ET_CONN_OTHER;
Willy Tarreaufa7e1022008-10-19 07:30:41 +02001171 }
1172
Willy Tarreau827aee92011-03-10 16:55:02 +01001173 if (srv)
1174 srv_inc_sess_ctr(srv);
1175 if (srv)
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -05001176 srv_set_sess_last(srv);
1177 if (srv)
Willy Tarreau827aee92011-03-10 16:55:02 +01001178 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001179 t->be->be_counters.failed_conns++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001180
1181 /* release other sessions waiting for this server */
Willy Tarreau827aee92011-03-10 16:55:02 +01001182 if (may_dequeue_tasks(srv, t->be))
1183 process_srv_queue(srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001184 return 1;
1185 }
1186 /* if we get here, it's because we got SRV_STATUS_OK, which also
1187 * means that the connection has not been queued.
1188 */
1189 return 0;
1190}
1191
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001192/* Apply RDP cookie persistence to the current session. For this, the function
1193 * tries to extract an RDP cookie from the request buffer, and look for the
1194 * matching server in the list. If the server is found, it is assigned to the
1195 * session. This always returns 1, and the analyser removes itself from the
1196 * list. Nothing is performed if a server was already assigned.
1197 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001198int tcp_persist_rdp_cookie(struct session *s, struct channel *req, int an_bit)
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001199{
1200 struct proxy *px = s->be;
1201 int ret;
Willy Tarreau37406352012-04-23 16:16:37 +02001202 struct sample smp;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001203 struct server *srv = px->srv;
1204 struct sockaddr_in addr;
1205 char *p;
1206
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001207 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 +02001208 now_ms, __FUNCTION__,
1209 s,
1210 req,
1211 req->rex, req->wex,
1212 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001213 req->buf->i,
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001214 req->analysers);
1215
1216 if (s->flags & SN_ASSIGNED)
1217 goto no_cookie;
1218
Willy Tarreau37406352012-04-23 16:16:37 +02001219 memset(&smp, 0, sizeof(smp));
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001220
Willy Tarreaucadd8c92013-07-22 18:09:52 +02001221 ret = fetch_rdp_cookie_name(s, &smp, s->be->rdp_cookie_name, s->be->rdp_cookie_len);
Willy Tarreauf853c462012-04-23 18:53:56 +02001222 if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || smp.data.str.len == 0)
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001223 goto no_cookie;
1224
1225 memset(&addr, 0, sizeof(addr));
1226 addr.sin_family = AF_INET;
1227
Willy Tarreau664092c2011-12-16 19:11:42 +01001228 /* Considering an rdp cookie detected using acl, str ended with <cr><lf> and should return */
Willy Tarreauf853c462012-04-23 18:53:56 +02001229 addr.sin_addr.s_addr = strtoul(smp.data.str.str, &p, 10);
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001230 if (*p != '.')
1231 goto no_cookie;
1232 p++;
1233 addr.sin_port = (unsigned short)strtoul(p, &p, 10);
1234 if (*p != '.')
1235 goto no_cookie;
1236
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001237 s->target = NULL;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001238 while (srv) {
1239 if (memcmp(&addr, &(srv->addr), sizeof(addr)) == 0) {
1240 if ((srv->state & SRV_RUNNING) || (px->options & PR_O_PERSIST)) {
1241 /* we found the server and it is usable */
1242 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001243 s->target = &srv->obj_type;
Willy Tarreau44b90cc2010-05-24 20:27:29 +02001244 break;
1245 }
1246 }
1247 srv = srv->next;
1248 }
1249
1250no_cookie:
1251 req->analysers &= ~an_bit;
1252 req->analyse_exp = TICK_ETERNITY;
1253 return 1;
1254}
1255
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001256int be_downtime(struct proxy *px) {
Willy Tarreaub625a082007-11-26 01:15:43 +01001257 if (px->lbprm.tot_weight && px->last_change < now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +02001258 return px->down_time;
1259
1260 return now.tv_sec - px->last_change + px->down_time;
1261}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001262
Krzysztof Piotr Oledzki15514c22010-01-04 16:03:09 +01001263/*
1264 * This function returns a string containing the balancing
1265 * mode of the proxy in a format suitable for stats.
1266 */
1267
1268const char *backend_lb_algo_str(int algo) {
1269
1270 if (algo == BE_LB_ALGO_RR)
1271 return "roundrobin";
1272 else if (algo == BE_LB_ALGO_SRR)
1273 return "static-rr";
Willy Tarreauf09c6602012-02-13 17:12:08 +01001274 else if (algo == BE_LB_ALGO_FAS)
1275 return "first";
Krzysztof Piotr Oledzki15514c22010-01-04 16:03:09 +01001276 else if (algo == BE_LB_ALGO_LC)
1277 return "leastconn";
1278 else if (algo == BE_LB_ALGO_SH)
1279 return "source";
1280 else if (algo == BE_LB_ALGO_UH)
1281 return "uri";
1282 else if (algo == BE_LB_ALGO_PH)
1283 return "url_param";
1284 else if (algo == BE_LB_ALGO_HH)
1285 return "hdr";
1286 else if (algo == BE_LB_ALGO_RCH)
1287 return "rdp-cookie";
1288 else
1289 return NULL;
1290}
1291
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001292/* This function parses a "balance" statement in a backend section describing
1293 * <curproxy>. It returns -1 if there is any error, otherwise zero. If it
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001294 * returns -1, it will write an error message into the <err> buffer which will
1295 * automatically be allocated and must be passed as NULL. The trailing '\n'
1296 * will not be written. The function must be called with <args> pointing to the
1297 * first word after "balance".
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001298 */
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001299int backend_parse_balance(const char **args, char **err, struct proxy *curproxy)
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001300{
1301 if (!*(args[0])) {
1302 /* if no option is set, use round-robin by default */
Willy Tarreau31682232007-11-29 15:38:04 +01001303 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1304 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001305 return 0;
1306 }
1307
1308 if (!strcmp(args[0], "roundrobin")) {
Willy Tarreau31682232007-11-29 15:38:04 +01001309 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1310 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001311 }
Willy Tarreau9757a382009-10-03 12:56:50 +02001312 else if (!strcmp(args[0], "static-rr")) {
1313 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1314 curproxy->lbprm.algo |= BE_LB_ALGO_SRR;
1315 }
Willy Tarreauf09c6602012-02-13 17:12:08 +01001316 else if (!strcmp(args[0], "first")) {
1317 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1318 curproxy->lbprm.algo |= BE_LB_ALGO_FAS;
1319 }
Willy Tarreau51406232008-03-10 22:04:20 +01001320 else if (!strcmp(args[0], "leastconn")) {
1321 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1322 curproxy->lbprm.algo |= BE_LB_ALGO_LC;
1323 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001324 else if (!strcmp(args[0], "source")) {
Willy Tarreau31682232007-11-29 15:38:04 +01001325 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1326 curproxy->lbprm.algo |= BE_LB_ALGO_SH;
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001327 }
1328 else if (!strcmp(args[0], "uri")) {
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001329 int arg = 1;
1330
Willy Tarreau31682232007-11-29 15:38:04 +01001331 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1332 curproxy->lbprm.algo |= BE_LB_ALGO_UH;
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001333
Oskar Stolc8dc41842012-05-19 10:19:54 +01001334 curproxy->uri_whole = 0;
1335
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001336 while (*args[arg]) {
1337 if (!strcmp(args[arg], "len")) {
1338 if (!*args[arg+1] || (atoi(args[arg+1]) <= 0)) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001339 memprintf(err, "%s : '%s' expects a positive integer (got '%s').", args[0], args[arg], args[arg+1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001340 return -1;
1341 }
1342 curproxy->uri_len_limit = atoi(args[arg+1]);
1343 arg += 2;
1344 }
1345 else if (!strcmp(args[arg], "depth")) {
1346 if (!*args[arg+1] || (atoi(args[arg+1]) <= 0)) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001347 memprintf(err, "%s : '%s' expects a positive integer (got '%s').", args[0], args[arg], args[arg+1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001348 return -1;
1349 }
1350 /* hint: we store the position of the ending '/' (depth+1) so
1351 * that we avoid a comparison while computing the hash.
1352 */
1353 curproxy->uri_dirs_depth1 = atoi(args[arg+1]) + 1;
1354 arg += 2;
1355 }
Oskar Stolc8dc41842012-05-19 10:19:54 +01001356 else if (!strcmp(args[arg], "whole")) {
1357 curproxy->uri_whole = 1;
1358 arg += 1;
1359 }
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001360 else {
Oskar Stolc8dc41842012-05-19 10:19:54 +01001361 memprintf(err, "%s only accepts parameters 'len', 'depth', and 'whole' (got '%s').", args[0], args[arg]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001362 return -1;
1363 }
1364 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001365 }
Willy Tarreau01732802007-11-01 22:48:15 +01001366 else if (!strcmp(args[0], "url_param")) {
1367 if (!*args[1]) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001368 memprintf(err, "%s requires an URL parameter name.", args[0]);
Willy Tarreau01732802007-11-01 22:48:15 +01001369 return -1;
1370 }
Willy Tarreau31682232007-11-29 15:38:04 +01001371 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1372 curproxy->lbprm.algo |= BE_LB_ALGO_PH;
Willy Tarreaua534fea2008-08-03 12:19:50 +02001373
1374 free(curproxy->url_param_name);
Willy Tarreau01732802007-11-01 22:48:15 +01001375 curproxy->url_param_name = strdup(args[1]);
Willy Tarreaua534fea2008-08-03 12:19:50 +02001376 curproxy->url_param_len = strlen(args[1]);
Marek Majkowski9c30fc12008-04-27 23:25:55 +02001377 if (*args[2]) {
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001378 if (strcmp(args[2], "check_post")) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001379 memprintf(err, "%s only accepts 'check_post' modifier (got '%s').", args[0], args[2]);
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001380 return -1;
1381 }
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +02001382 }
Benoitaffb4812009-03-25 13:02:10 +01001383 }
1384 else if (!strncmp(args[0], "hdr(", 4)) {
1385 const char *beg, *end;
1386
1387 beg = args[0] + 4;
1388 end = strchr(beg, ')');
1389
1390 if (!end || end == beg) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001391 memprintf(err, "hdr requires an http header field name.");
Benoitaffb4812009-03-25 13:02:10 +01001392 return -1;
1393 }
1394
1395 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1396 curproxy->lbprm.algo |= BE_LB_ALGO_HH;
1397
1398 free(curproxy->hh_name);
1399 curproxy->hh_len = end - beg;
1400 curproxy->hh_name = my_strndup(beg, end - beg);
1401 curproxy->hh_match_domain = 0;
1402
1403 if (*args[1]) {
1404 if (strcmp(args[1], "use_domain_only")) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001405 memprintf(err, "%s only accepts 'use_domain_only' modifier (got '%s').", args[0], args[1]);
Benoitaffb4812009-03-25 13:02:10 +01001406 return -1;
1407 }
1408 curproxy->hh_match_domain = 1;
1409 }
Emeric Brun736aa232009-06-30 17:56:00 +02001410 }
1411 else if (!strncmp(args[0], "rdp-cookie", 10)) {
1412 curproxy->lbprm.algo &= ~BE_LB_ALGO;
1413 curproxy->lbprm.algo |= BE_LB_ALGO_RCH;
1414
1415 if ( *(args[0] + 10 ) == '(' ) { /* cookie name */
1416 const char *beg, *end;
1417
1418 beg = args[0] + 11;
1419 end = strchr(beg, ')');
1420
1421 if (!end || end == beg) {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001422 memprintf(err, "rdp-cookie : missing cookie name.");
Emeric Brun736aa232009-06-30 17:56:00 +02001423 return -1;
1424 }
1425
1426 free(curproxy->hh_name);
1427 curproxy->hh_name = my_strndup(beg, end - beg);
1428 curproxy->hh_len = end - beg;
1429 }
1430 else if ( *(args[0] + 10 ) == '\0' ) { /* default cookie name 'mstshash' */
1431 free(curproxy->hh_name);
1432 curproxy->hh_name = strdup("mstshash");
1433 curproxy->hh_len = strlen(curproxy->hh_name);
1434 }
1435 else { /* syntax */
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001436 memprintf(err, "rdp-cookie : missing cookie name.");
Emeric Brun736aa232009-06-30 17:56:00 +02001437 return -1;
1438 }
Willy Tarreau01732802007-11-01 22:48:15 +01001439 }
Willy Tarreaua0cbda62007-11-01 21:39:54 +01001440 else {
Willy Tarreaua93c74b2012-05-08 18:14:39 +02001441 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 +01001442 return -1;
1443 }
1444 return 0;
1445}
1446
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001447
1448/************************************************************************/
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001449/* All supported sample and ACL keywords must be declared here. */
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001450/************************************************************************/
1451
Willy Tarreau34db1082012-04-19 17:16:54 +02001452/* set temp integer to the number of enabled servers on the proxy.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001453 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001454 * undefined behaviour.
1455 */
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001456static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001457smp_fetch_nbsrv(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001458 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001459{
Willy Tarreau37406352012-04-23 16:16:37 +02001460 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001461 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001462 px = args->data.prx;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001463
1464 if (px->srv_act)
Willy Tarreauf853c462012-04-23 18:53:56 +02001465 smp->data.uint = px->srv_act;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001466 else if (px->lbprm.fbck)
Willy Tarreauf853c462012-04-23 18:53:56 +02001467 smp->data.uint = 1;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001468 else
Willy Tarreauf853c462012-04-23 18:53:56 +02001469 smp->data.uint = px->srv_bck;
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001470
1471 return 1;
1472}
1473
Willy Tarreau37406352012-04-23 16:16:37 +02001474/* report in smp->flags a success or failure depending on the designated
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001475 * server's state. There is no match function involved since there's no pattern.
Willy Tarreau34db1082012-04-19 17:16:54 +02001476 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1477 * undefined behaviour.
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001478 */
1479static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001480smp_fetch_srv_is_up(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001481 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001482{
Willy Tarreau24e32d82012-04-23 23:55:44 +02001483 struct server *srv = args->data.srv;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001484
Willy Tarreau37406352012-04-23 16:16:37 +02001485 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001486 smp->type = SMP_T_BOOL;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001487 if (!(srv->state & SRV_MAINTAIN) &&
Willy Tarreauff5ae352013-12-11 20:36:34 +01001488 (!(srv->check.state & CHK_ST_CONFIGURED) || (srv->state & SRV_RUNNING)))
Willy Tarreau197e10a2012-04-23 19:18:42 +02001489 smp->data.uint = 1;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001490 else
Willy Tarreau197e10a2012-04-23 19:18:42 +02001491 smp->data.uint = 0;
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001492 return 1;
1493}
1494
Willy Tarreau34db1082012-04-19 17:16:54 +02001495/* set temp integer to the number of enabled servers on the proxy.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001496 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001497 * undefined behaviour.
1498 */
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001499static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001500smp_fetch_connslots(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001501 const struct arg *args, struct sample *smp, const char *kw)
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001502{
1503 struct server *iterator;
Willy Tarreaud28c3532012-04-19 19:28:33 +02001504
Willy Tarreau37406352012-04-23 16:16:37 +02001505 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001506 smp->type = SMP_T_UINT;
1507 smp->data.uint = 0;
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001508
Willy Tarreau24e32d82012-04-23 23:55:44 +02001509 for (iterator = args->data.prx->srv; iterator; iterator = iterator->next) {
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001510 if ((iterator->state & SRV_RUNNING) == 0)
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001511 continue;
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001512
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001513 if (iterator->maxconn == 0 || iterator->maxqueue == 0) {
Willy Tarreaua5e37562011-12-16 17:06:15 +01001514 /* configuration is stupid */
Willy Tarreauf853c462012-04-23 18:53:56 +02001515 smp->data.uint = -1; /* FIXME: stupid value! */
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001516 return 1;
1517 }
1518
Willy Tarreauf853c462012-04-23 18:53:56 +02001519 smp->data.uint += (iterator->maxconn - iterator->cur_sess)
Willy Tarreau422aa072012-04-20 20:49:27 +02001520 + (iterator->maxqueue - iterator->nbpend);
Jeffrey 'jf' Lim5051d7b2008-09-04 01:03:03 +08001521 }
1522
1523 return 1;
1524}
1525
Willy Tarreaua5e37562011-12-16 17:06:15 +01001526/* set temp integer to the id of the backend */
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001527static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001528smp_fetch_be_id(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 Tarreau37406352012-04-23 16:16:37 +02001530{
Willy Tarreauf853c462012-04-23 18:53:56 +02001531 smp->flags = SMP_F_VOL_TXN;
1532 smp->type = SMP_T_UINT;
1533 smp->data.uint = l4->be->uuid;
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001534 return 1;
1535}
1536
Willy Tarreaua5e37562011-12-16 17:06:15 +01001537/* set temp integer to the id of the server */
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001538static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001539smp_fetch_srv_id(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001540 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau37406352012-04-23 16:16:37 +02001541{
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001542 if (!objt_server(l4->target))
Willy Tarreau17af4192011-02-23 14:27:06 +01001543 return 0;
1544
Willy Tarreauf853c462012-04-23 18:53:56 +02001545 smp->type = SMP_T_UINT;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001546 smp->data.uint = objt_server(l4->target)->puid;
Hervé COMMOWICK35ed8012010-12-15 14:04:51 +01001547
1548 return 1;
1549}
1550
Willy Tarreau34db1082012-04-19 17:16:54 +02001551/* set temp integer to the number of connections per second reaching the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001552 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001553 * undefined behaviour.
1554 */
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001555static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001556smp_fetch_be_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001557 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001558{
Willy Tarreau37406352012-04-23 16:16:37 +02001559 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001560 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001561 smp->data.uint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
Willy Tarreau079ff0a2009-03-05 21:34:28 +01001562 return 1;
1563}
1564
Willy Tarreau34db1082012-04-19 17:16:54 +02001565/* set temp integer to the number of concurrent connections on the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001566 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001567 * undefined behaviour.
1568 */
Willy Tarreaua36af912009-10-10 12:02:45 +02001569static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001570smp_fetch_be_conn(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001571 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001572{
Willy Tarreau37406352012-04-23 16:16:37 +02001573 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001574 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001575 smp->data.uint = args->data.prx->beconn;
Willy Tarreaua36af912009-10-10 12:02:45 +02001576 return 1;
1577}
1578
Willy Tarreau34db1082012-04-19 17:16:54 +02001579/* set temp integer to the total number of queued connections on the backend.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001580 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001581 * undefined behaviour.
1582 */
Willy Tarreaua36af912009-10-10 12:02:45 +02001583static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001584smp_fetch_queue_size(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)
Willy Tarreaua36af912009-10-10 12:02:45 +02001586{
Willy Tarreau37406352012-04-23 16:16:37 +02001587 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001588 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001589 smp->data.uint = args->data.prx->totpend;
Willy Tarreaua36af912009-10-10 12:02:45 +02001590 return 1;
1591}
1592
Willy Tarreaua5e37562011-12-16 17:06:15 +01001593/* set temp integer to the total number of queued connections on the backend divided
Willy Tarreaua36af912009-10-10 12:02:45 +02001594 * by the number of running servers and rounded up. If there is no running
1595 * server, we return twice the total, just as if we had half a running server.
1596 * This is more or less correct anyway, since we expect the last server to come
1597 * back soon.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02001598 * Accepts exactly 1 argument. Argument is a backend, other types will lead to
Willy Tarreau34db1082012-04-19 17:16:54 +02001599 * undefined behaviour.
Willy Tarreaua36af912009-10-10 12:02:45 +02001600 */
1601static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001602smp_fetch_avg_queue_size(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001603 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreaua36af912009-10-10 12:02:45 +02001604{
1605 int nbsrv;
1606
Willy Tarreau37406352012-04-23 16:16:37 +02001607 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02001608 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001609 px = args->data.prx;
Willy Tarreaua36af912009-10-10 12:02:45 +02001610
1611 if (px->srv_act)
1612 nbsrv = px->srv_act;
1613 else if (px->lbprm.fbck)
1614 nbsrv = 1;
1615 else
1616 nbsrv = px->srv_bck;
1617
1618 if (nbsrv > 0)
Willy Tarreauf853c462012-04-23 18:53:56 +02001619 smp->data.uint = (px->totpend + nbsrv - 1) / nbsrv;
Willy Tarreaua36af912009-10-10 12:02:45 +02001620 else
Willy Tarreauf853c462012-04-23 18:53:56 +02001621 smp->data.uint = px->totpend * 2;
Willy Tarreaua36af912009-10-10 12:02:45 +02001622
1623 return 1;
1624}
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001625
Willy Tarreau34db1082012-04-19 17:16:54 +02001626/* set temp integer to the number of concurrent connections on the server in the backend.
1627 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1628 * undefined behaviour.
1629 */
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001630static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001631smp_fetch_srv_conn(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001632 const struct arg *args, struct sample *smp, const char *kw)
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001633{
Willy Tarreauf853c462012-04-23 18:53:56 +02001634 smp->flags = SMP_F_VOL_TEST;
1635 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02001636 smp->data.uint = args->data.srv->cur_sess;
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001637 return 1;
1638}
1639
Tait Clarridge7896d522012-12-05 21:39:31 -05001640/* set temp integer to the number of enabled servers on the proxy.
1641 * Accepts exactly 1 argument. Argument is a server, other types will lead to
1642 * undefined behaviour.
1643 */
1644static int
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001645smp_fetch_srv_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001646 const struct arg *args, struct sample *smp, const char *kw)
Tait Clarridge7896d522012-12-05 21:39:31 -05001647{
1648 smp->flags = SMP_F_VOL_TEST;
1649 smp->type = SMP_T_UINT;
1650 smp->data.uint = read_freq_ctr(&args->data.srv->sess_per_sec);
1651 return 1;
1652}
1653
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001654
1655/* Note: must not be declared <const> as its list will be overwritten.
1656 * Please take care of keeping this list alphabetically sorted.
1657 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001658static struct sample_fetch_kw_list smp_kws = {ILH, {
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001659 { "avg_queue", smp_fetch_avg_queue_size, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1660 { "be_conn", smp_fetch_be_conn, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1661 { "be_id", smp_fetch_be_id, 0, NULL, SMP_T_UINT, SMP_USE_BKEND, },
1662 { "be_sess_rate", smp_fetch_be_sess_rate, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1663 { "connslots", smp_fetch_connslots, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1664 { "nbsrv", smp_fetch_nbsrv, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1665 { "queue", smp_fetch_queue_size, ARG1(1,BE), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1666 { "srv_conn", smp_fetch_srv_conn, ARG1(1,SRV), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1667 { "srv_id", smp_fetch_srv_id, 0, NULL, SMP_T_UINT, SMP_USE_SERVR, },
1668 { "srv_is_up", smp_fetch_srv_is_up, ARG1(1,SRV), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
1669 { "srv_sess_rate", smp_fetch_srv_sess_rate, ARG1(1,SRV), NULL, SMP_T_UINT, SMP_USE_INTRN, },
1670 { /* END */ },
1671}};
1672
1673
Willy Tarreau61612d42012-04-19 18:42:05 +02001674/* Note: must not be declared <const> as its list will be overwritten.
1675 * Please take care of keeping this list alphabetically sorted.
1676 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001677static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001678 { /* END */ },
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001679}};
1680
1681
1682__attribute__((constructor))
1683static void __backend_init(void)
1684{
Willy Tarreau1a7eca12013-01-07 22:38:03 +01001685 sample_register_fetches(&smp_kws);
Willy Tarreaua9d3c1e2007-11-30 20:48:53 +01001686 acl_register_keywords(&acl_kws);
1687}
1688
Willy Tarreaubaaee002006-06-26 02:48:02 +02001689/*
1690 * Local variables:
1691 * c-indent-level: 8
1692 * c-basic-offset: 8
1693 * End:
1694 */