blob: 595e0e31898776a775b8707241876731f529f830 [file] [log] [blame]
Willy Tarreau79e57332018-10-02 16:01:16 +02001/*
2 * HTTP samples fetching
3 *
4 * Copyright 2000-2018 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <sys/types.h>
14
15#include <ctype.h>
16#include <string.h>
17#include <time.h>
18
Willy Tarreaub2551052020-06-09 09:07:15 +020019#include <haproxy/api.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020020#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020021#include <haproxy/auth.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020022#include <haproxy/base64.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020023#include <haproxy/channel.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020024#include <haproxy/chunk.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020025#include <haproxy/connection.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020026#include <haproxy/global.h>
Willy Tarreau5413a872020-06-02 19:33:08 +020027#include <haproxy/h1.h>
Willy Tarreauc6fe8842020-06-04 09:00:02 +020028#include <haproxy/h1_htx.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020029#include <haproxy/http.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020030#include <haproxy/http_ana.h>
Willy Tarreau126ba3a2020-06-04 18:26:43 +020031#include <haproxy/http_fetch.h>
Willy Tarreau87735332020-06-04 09:08:41 +020032#include <haproxy/http_htx.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020033#include <haproxy/htx.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020034#include <haproxy/obj_type.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020035#include <haproxy/pool.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020036#include <haproxy/sample.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020037#include <haproxy/stream.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020038#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020039#include <haproxy/version.h>
Willy Tarreau79e57332018-10-02 16:01:16 +020040
Willy Tarreau79e57332018-10-02 16:01:16 +020041
42/* this struct is used between calls to smp_fetch_hdr() or smp_fetch_cookie() */
Christopher Fauletef453ed2018-10-24 21:39:27 +020043static THREAD_LOCAL struct http_hdr_ctx static_http_hdr_ctx;
Richard Russo458eafb2019-07-31 11:45:56 -070044/* this is used to convert raw connection buffers to htx */
45static THREAD_LOCAL struct buffer static_raw_htx_chunk;
46static THREAD_LOCAL char *static_raw_htx_buf;
Christopher Fauletef453ed2018-10-24 21:39:27 +020047
Christopher Faulet89dc4992019-04-17 12:02:59 +020048#define SMP_REQ_CHN(smp) (smp->strm ? &smp->strm->req : NULL)
49#define SMP_RES_CHN(smp) (smp->strm ? &smp->strm->res : NULL)
Willy Tarreau79e57332018-10-02 16:01:16 +020050
Richard Russo458eafb2019-07-31 11:45:56 -070051/* This function returns the static htx chunk, where raw connections get
52 * converted to HTX as needed for samplxsing.
53 */
54struct buffer *get_raw_htx_chunk(void)
55{
56 chunk_reset(&static_raw_htx_chunk);
57 return &static_raw_htx_chunk;
58}
59
60static int alloc_raw_htx_chunk_per_thread()
61{
62 static_raw_htx_buf = malloc(global.tune.bufsize);
63 if (!static_raw_htx_buf)
64 return 0;
65 chunk_init(&static_raw_htx_chunk, static_raw_htx_buf, global.tune.bufsize);
66 return 1;
67}
68
69static void free_raw_htx_chunk_per_thread()
70{
71 free(static_raw_htx_buf);
72 static_raw_htx_buf = NULL;
73}
74
75REGISTER_PER_THREAD_ALLOC(alloc_raw_htx_chunk_per_thread);
76REGISTER_PER_THREAD_FREE(free_raw_htx_chunk_per_thread);
77
Willy Tarreau79e57332018-10-02 16:01:16 +020078/*
79 * Returns the data from Authorization header. Function may be called more
80 * than once so data is stored in txn->auth_data. When no header is found
81 * or auth method is unknown auth_method is set to HTTP_AUTH_WRONG to avoid
82 * searching again for something we are unable to find anyway. However, if
83 * the result if valid, the cache is not reused because we would risk to
84 * have the credentials overwritten by another stream in parallel.
Willy Tarreaueae83722020-04-29 11:52:51 +020085 * The caller is responsible for passing a sample with a valid stream/txn,
86 * and a valid htx.
Willy Tarreau79e57332018-10-02 16:01:16 +020087 */
88
Christopher Fauletcd761952019-07-15 13:58:29 +020089static int get_http_auth(struct sample *smp, struct htx *htx)
Willy Tarreau79e57332018-10-02 16:01:16 +020090{
Christopher Faulet311c7ea2018-10-24 21:41:55 +020091 struct stream *s = smp->strm;
Willy Tarreau79e57332018-10-02 16:01:16 +020092 struct http_txn *txn = s->txn;
Christopher Faulet6d1dd462019-07-15 14:36:03 +020093 struct http_hdr_ctx ctx = { .blk = NULL };
94 struct ist hdr;
Willy Tarreau79e57332018-10-02 16:01:16 +020095 struct buffer auth_method;
Christopher Faulet6d1dd462019-07-15 14:36:03 +020096 char *p;
Willy Tarreau79e57332018-10-02 16:01:16 +020097 int len;
98
99#ifdef DEBUG_AUTH
100 printf("Auth for stream %p: %d\n", s, txn->auth.method);
101#endif
Willy Tarreau79e57332018-10-02 16:01:16 +0200102 if (txn->auth.method == HTTP_AUTH_WRONG)
103 return 0;
104
105 txn->auth.method = HTTP_AUTH_WRONG;
106
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200107 if (txn->flags & TX_USE_PX_CONN)
108 hdr = ist("Proxy-Authorization");
109 else
110 hdr = ist("Authorization");
Willy Tarreau79e57332018-10-02 16:01:16 +0200111
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200112 ctx.blk = NULL;
113 if (!http_find_header(htx, hdr, &ctx, 0))
114 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200115
Willy Tarreau17254932020-09-02 07:08:47 +0200116 p = memchr(ctx.value.ptr, ' ', ctx.value.len);
117 if (!p || p == ctx.value.ptr) /* if no space was found or if the space is the first character */
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200118 return 0;
Willy Tarreau17254932020-09-02 07:08:47 +0200119 len = p - ctx.value.ptr;
Willy Tarreau79e57332018-10-02 16:01:16 +0200120
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200121 if (chunk_initlen(&auth_method, ctx.value.ptr, 0, len) != 1)
122 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200123
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200124 chunk_initlen(&txn->auth.method_data, p + 1, 0, ctx.value.len - len - 1);
Willy Tarreau79e57332018-10-02 16:01:16 +0200125
126 if (!strncasecmp("Basic", auth_method.area, auth_method.data)) {
127 struct buffer *http_auth = get_trash_chunk();
128
129 len = base64dec(txn->auth.method_data.area,
130 txn->auth.method_data.data,
131 http_auth->area, global.tune.bufsize - 1);
132
133 if (len < 0)
134 return 0;
135
136
137 http_auth->area[len] = '\0';
138
139 p = strchr(http_auth->area, ':');
140
141 if (!p)
142 return 0;
143
144 txn->auth.user = http_auth->area;
145 *p = '\0';
146 txn->auth.pass = p+1;
147
148 txn->auth.method = HTTP_AUTH_BASIC;
149 return 1;
150 }
151
152 return 0;
153}
154
155/* This function ensures that the prerequisites for an L7 fetch are ready,
156 * which means that a request or response is ready. If some data is missing,
157 * a parsing attempt is made. This is useful in TCP-based ACLs which are able
Christopher Faulet5ec8bcb2019-04-17 12:04:12 +0200158 * to extract data from L7. If <vol> is non-null during a prefetch, another
159 * test is made to ensure the required information is not gone.
Christopher Fauletef453ed2018-10-24 21:39:27 +0200160 *
161 * The function returns :
162 * NULL with SMP_F_MAY_CHANGE in the sample flags if some data is missing to
163 * decide whether or not an HTTP message is present ;
164 * NULL if the requested data cannot be fetched or if it is certain that
Willy Tarreaueae83722020-04-29 11:52:51 +0200165 * we'll never have any HTTP message there; this includes null strm or chn.
Willy Tarreaua6d98792020-08-12 14:04:52 +0200166 * NULL if the sample's direction does not match the channel's (i.e. the
167 * function was asked to work on the wrong channel)
Christopher Fauletef453ed2018-10-24 21:39:27 +0200168 * The HTX message if ready
169 */
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200170struct htx *smp_prefetch_htx(struct sample *smp, struct channel *chn, struct check *check, int vol)
Christopher Fauletef453ed2018-10-24 21:39:27 +0200171{
Christopher Fauletef453ed2018-10-24 21:39:27 +0200172 struct stream *s = smp->strm;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200173 struct http_txn *txn = NULL;
174 struct htx *htx = NULL;
Christopher Faulet89dc4992019-04-17 12:02:59 +0200175 struct http_msg *msg;
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100176 struct htx_sl *sl;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200177
Willy Tarreaua6d98792020-08-12 14:04:52 +0200178 if (chn &&
179 (((smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ && (chn->flags & CF_ISRESP)) ||
180 ((smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_RES && !(chn->flags & CF_ISRESP))))
181 return 0;
182
Christopher Fauletef453ed2018-10-24 21:39:27 +0200183 /* Note: it is possible that <s> is NULL when called before stream
184 * initialization (eg: tcp-request connection), so this function is the
185 * one responsible for guarding against this case for all HTTP users.
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200186 *
187 * In the health check context, the stream and the channel must be NULL
188 * and <check> must be set. In this case, only the input buffer,
189 * corresponding to the response, is considered. It is the caller
190 * responsibility to provide <check>.
Christopher Fauletef453ed2018-10-24 21:39:27 +0200191 */
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200192 BUG_ON(check && (s || chn));
193 if (!s || !chn) {
194 if (check) {
195 htx = htxbuf(&check->bi);
196
197 /* Analyse not yet started */
198 if (htx_is_empty(htx) || htx->first == -1)
199 return NULL;
200
201 sl = http_get_stline(htx);
202 if (vol && !sl) {
203 /* The start-line was already forwarded, it is too late to fetch anything */
204 return NULL;
205 }
206 goto end;
207 }
208
Christopher Fauletef453ed2018-10-24 21:39:27 +0200209 return NULL;
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200210 }
Christopher Fauletef453ed2018-10-24 21:39:27 +0200211
212 if (!s->txn) {
213 if (unlikely(!http_alloc_txn(s)))
214 return NULL; /* not enough memory */
215 http_init_txn(s);
216 txn = s->txn;
217 }
Christopher Faulet89dc4992019-04-17 12:02:59 +0200218 txn = s->txn;
219 msg = (!(chn->flags & CF_ISRESP) ? &txn->req : &txn->rsp);
Christopher Fauletef453ed2018-10-24 21:39:27 +0200220
Christopher Fauleteca88542019-04-03 10:12:42 +0200221 if (IS_HTX_STRM(s)) {
Christopher Faulet89dc4992019-04-17 12:02:59 +0200222 htx = htxbuf(&chn->buf);
Christopher Fauletef453ed2018-10-24 21:39:27 +0200223
Christopher Faulet89dc4992019-04-17 12:02:59 +0200224 if (msg->msg_state == HTTP_MSG_ERROR || (htx->flags & HTX_FL_PARSING_ERROR))
225 return NULL;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200226
Christopher Faulet89dc4992019-04-17 12:02:59 +0200227 if (msg->msg_state < HTTP_MSG_BODY) {
228 /* Analyse not yet started */
Christopher Faulet29f17582019-05-23 11:03:26 +0200229 if (htx_is_empty(htx) || htx->first == -1) {
Christopher Fauletef453ed2018-10-24 21:39:27 +0200230 /* Parsing is done by the mux, just wait */
231 smp->flags |= SMP_F_MAY_CHANGE;
232 return NULL;
233 }
234 }
Christopher Faulet297fbb42019-05-13 14:41:27 +0200235 sl = http_get_stline(htx);
Christopher Faulet5ec8bcb2019-04-17 12:04:12 +0200236 if (vol && !sl) {
Christopher Faulet89dc4992019-04-17 12:02:59 +0200237 /* The start-line was already forwarded, it is too late to fetch anything */
238 return NULL;
239 }
Christopher Fauletef453ed2018-10-24 21:39:27 +0200240 }
Christopher Fauleteca88542019-04-03 10:12:42 +0200241 else { /* RAW mode */
Christopher Faulet89dc4992019-04-17 12:02:59 +0200242 struct buffer *buf;
243 struct h1m h1m;
Christopher Faulete4ab11b2019-06-11 15:05:37 +0200244 struct http_hdr hdrs[global.tune.max_http_hdr];
Christopher Faulet89dc4992019-04-17 12:02:59 +0200245 union h1_sl h1sl;
246 unsigned int flags = HTX_FL_NONE;
247 int ret;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200248
Christopher Faulet89dc4992019-04-17 12:02:59 +0200249 /* no HTTP fetch on the response in TCP mode */
250 if (chn->flags & CF_ISRESP)
251 return NULL;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200252
Christopher Faulet89dc4992019-04-17 12:02:59 +0200253 /* Now we are working on the request only */
254 buf = &chn->buf;
255 if (b_head(buf) + b_data(buf) > b_wrap(buf))
256 b_slow_realign(buf, trash.area, 0);
Christopher Fauletef453ed2018-10-24 21:39:27 +0200257
Christopher Faulet89dc4992019-04-17 12:02:59 +0200258 h1m_init_req(&h1m);
259 ret = h1_headers_to_hdr_list(b_head(buf), b_stop(buf),
260 hdrs, sizeof(hdrs)/sizeof(hdrs[0]), &h1m, &h1sl);
261 if (ret <= 0) {
262 /* Invalid or too big*/
263 if (ret < 0 || channel_full(&s->req, global.tune.maxrewrite))
Christopher Fauletef453ed2018-10-24 21:39:27 +0200264 return NULL;
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100265
Christopher Faulet89dc4992019-04-17 12:02:59 +0200266 /* wait for a full request */
267 smp->flags |= SMP_F_MAY_CHANGE;
268 return NULL;
269 }
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100270
Ilya Shipitsin46a030c2020-07-05 16:36:08 +0500271 /* OK we just got a valid HTTP message. We have to convert it
Christopher Faulet89dc4992019-04-17 12:02:59 +0200272 * into an HTX message.
273 */
274 if (unlikely(h1sl.rq.v.len == 0)) {
275 /* try to convert HTTP/0.9 requests to HTTP/1.0 */
276 if (h1sl.rq.meth != HTTP_METH_GET || !h1sl.rq.u.len)
Christopher Fauletef453ed2018-10-24 21:39:27 +0200277 return NULL;
Christopher Faulet89dc4992019-04-17 12:02:59 +0200278 h1sl.rq.v = ist("HTTP/1.0");
Christopher Fauletef453ed2018-10-24 21:39:27 +0200279 }
Christopher Faulet89dc4992019-04-17 12:02:59 +0200280
281 /* Set HTX start-line flags */
282 if (h1m.flags & H1_MF_VER_11)
283 flags |= HTX_SL_F_VER_11;
284 if (h1m.flags & H1_MF_XFER_ENC)
285 flags |= HTX_SL_F_XFER_ENC;
286 flags |= HTX_SL_F_XFER_LEN;
287 if (h1m.flags & H1_MF_CHNK)
288 flags |= HTX_SL_F_CHNK;
289 else if (h1m.flags & H1_MF_CLEN)
290 flags |= HTX_SL_F_CLEN;
291
Richard Russo458eafb2019-07-31 11:45:56 -0700292 htx = htx_from_buf(get_raw_htx_chunk());
Christopher Faulet89dc4992019-04-17 12:02:59 +0200293 sl = htx_add_stline(htx, HTX_BLK_REQ_SL, flags, h1sl.rq.m, h1sl.rq.u, h1sl.rq.v);
294 if (!sl || !htx_add_all_headers(htx, hdrs))
Christopher Fauletef453ed2018-10-24 21:39:27 +0200295 return NULL;
Willy Tarreauce9bbf52019-05-13 08:32:31 +0200296 sl->info.req.meth = h1sl.rq.meth;
Christopher Faulet89dc4992019-04-17 12:02:59 +0200297 }
298
299 /* OK we just got a valid HTTP message. If not already done by
300 * HTTP analyzers, we have some minor preparation to perform so
301 * that further checks can rely on HTTP tests.
302 */
303 if (sl && msg->msg_state < HTTP_MSG_BODY) {
304 if (!(chn->flags & CF_ISRESP)) {
305 txn->meth = sl->info.req.meth;
306 if (txn->meth == HTTP_METH_GET || txn->meth == HTTP_METH_HEAD)
307 s->flags |= SF_REDIRECTABLE;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200308 }
Christopher Faulet89dc4992019-04-17 12:02:59 +0200309 else
310 txn->status = sl->info.res.status;
311 if (sl->flags & HTX_SL_F_VER_11)
312 msg->flags |= HTTP_MSGF_VER_11;
Christopher Fauletef453ed2018-10-24 21:39:27 +0200313 }
314
315 /* everything's OK */
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200316 end:
Christopher Fauletef453ed2018-10-24 21:39:27 +0200317 return htx;
318}
319
Willy Tarreau79e57332018-10-02 16:01:16 +0200320/* This function fetches the method of current HTTP request and stores
321 * it in the global pattern struct as a chunk. There are two possibilities :
322 * - if the method is known (not HTTP_METH_OTHER), its identifier is stored
323 * in <len> and <ptr> is NULL ;
324 * - if the method is unknown (HTTP_METH_OTHER), <ptr> points to the text and
325 * <len> to its length.
326 * This is intended to be used with pat_match_meth() only.
327 */
328static int smp_fetch_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
329{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200330 struct channel *chn = SMP_REQ_CHN(smp);
Willy Tarreau79e57332018-10-02 16:01:16 +0200331 struct http_txn *txn;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200332 int meth;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200333
Willy Tarreaua6d98792020-08-12 14:04:52 +0200334 txn = smp->strm->txn;
335 if (!txn)
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200336 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200337
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200338 meth = txn->meth;
339 smp->data.type = SMP_T_METH;
340 smp->data.u.meth.meth = meth;
341 if (meth == HTTP_METH_OTHER) {
Willy Tarreaua6d98792020-08-12 14:04:52 +0200342 struct htx *htx;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200343 struct htx_sl *sl;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200344
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200345 if ((smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_RES) {
346 /* ensure the indexes are not affected */
347 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200348 }
Willy Tarreaua6d98792020-08-12 14:04:52 +0200349
350 htx = smp_prefetch_htx(smp, chn, NULL, 0);
351 if (!htx)
352 return 0;
353
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200354 sl = http_get_stline(htx);
355 smp->flags |= SMP_F_CONST;
356 smp->data.u.meth.str.area = HTX_SL_REQ_MPTR(sl);
357 smp->data.u.meth.str.data = HTX_SL_REQ_MLEN(sl);
Willy Tarreau79e57332018-10-02 16:01:16 +0200358 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200359 smp->flags |= SMP_F_VOL_1ST;
Willy Tarreau79e57332018-10-02 16:01:16 +0200360 return 1;
361}
362
363static int smp_fetch_rqver(const struct arg *args, struct sample *smp, const char *kw, void *private)
364{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200365 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200366 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200367 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +0200368 char *ptr;
369 int len;
370
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200371 if (!htx)
372 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200373
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200374 sl = http_get_stline(htx);
375 len = HTX_SL_REQ_VLEN(sl);
376 ptr = HTX_SL_REQ_VPTR(sl);
Willy Tarreau79e57332018-10-02 16:01:16 +0200377
378 while ((len-- > 0) && (*ptr++ != '/'));
379 if (len <= 0)
380 return 0;
381
382 smp->data.type = SMP_T_STR;
383 smp->data.u.str.area = ptr;
384 smp->data.u.str.data = len;
385
386 smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
387 return 1;
388}
389
390static int smp_fetch_stver(const struct arg *args, struct sample *smp, const char *kw, void *private)
391{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200392 struct channel *chn = SMP_RES_CHN(smp);
Christopher Fauletf98e6262020-05-06 09:42:04 +0200393 struct check *check = objt_check(smp->sess->origin);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200394 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200395 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +0200396 char *ptr;
397 int len;
398
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200399 if (!htx)
400 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200401
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200402 sl = http_get_stline(htx);
403 len = HTX_SL_RES_VLEN(sl);
404 ptr = HTX_SL_RES_VPTR(sl);
Willy Tarreau79e57332018-10-02 16:01:16 +0200405
406 while ((len-- > 0) && (*ptr++ != '/'));
407 if (len <= 0)
408 return 0;
409
410 smp->data.type = SMP_T_STR;
411 smp->data.u.str.area = ptr;
412 smp->data.u.str.data = len;
413
414 smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
415 return 1;
416}
417
418/* 3. Check on Status Code. We manipulate integers here. */
419static int smp_fetch_stcode(const struct arg *args, struct sample *smp, const char *kw, void *private)
420{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200421 struct channel *chn = SMP_RES_CHN(smp);
Christopher Fauletf98e6262020-05-06 09:42:04 +0200422 struct check *check = objt_check(smp->sess->origin);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200423 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200424 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +0200425 char *ptr;
426 int len;
427
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200428 if (!htx)
429 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200430
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200431 sl = http_get_stline(htx);
432 len = HTX_SL_RES_CLEN(sl);
433 ptr = HTX_SL_RES_CPTR(sl);
Willy Tarreau79e57332018-10-02 16:01:16 +0200434
435 smp->data.type = SMP_T_SINT;
436 smp->data.u.sint = __strl2ui(ptr, len);
437 smp->flags = SMP_F_VOL_1ST;
438 return 1;
439}
440
441static int smp_fetch_uniqueid(const struct arg *args, struct sample *smp, const char *kw, void *private)
442{
Tim Duesterhusa17e6622020-03-05 20:19:02 +0100443 struct ist unique_id;
Tim Duesterhus2825b4b2020-02-28 15:13:34 +0100444
Willy Tarreau79e57332018-10-02 16:01:16 +0200445 if (LIST_ISEMPTY(&smp->sess->fe->format_unique_id))
446 return 0;
447
Willy Tarreaua1062a42020-04-29 11:50:38 +0200448 if (!smp->strm)
449 return 0;
450
Tim Duesterhusa17e6622020-03-05 20:19:02 +0100451 unique_id = stream_generate_unique_id(smp->strm, &smp->sess->fe->format_unique_id);
452 if (!isttest(unique_id))
Tim Duesterhus2825b4b2020-02-28 15:13:34 +0100453 return 0;
454
Tim Duesterhusa17e6622020-03-05 20:19:02 +0100455 smp->data.u.str.area = smp->strm->unique_id.ptr;
456 smp->data.u.str.data = smp->strm->unique_id.len;
Tim Duesterhus2825b4b2020-02-28 15:13:34 +0100457 smp->data.type = SMP_T_STR;
Willy Tarreau79e57332018-10-02 16:01:16 +0200458 smp->flags = SMP_F_CONST;
459 return 1;
460}
461
462/* Returns a string block containing all headers including the
Joseph Herlant942eea32018-11-15 13:57:22 -0800463 * empty line which separes headers from the body. This is useful
464 * for some headers analysis.
Willy Tarreau79e57332018-10-02 16:01:16 +0200465 */
466static int smp_fetch_hdrs(const struct arg *args, struct sample *smp, const char *kw, void *private)
467{
Christopher Faulete596d182020-05-05 17:46:34 +0200468 /* possible keywords: req.hdrs, res.hdrs */
469 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200470 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200471 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200472 struct buffer *temp;
473 int32_t pos;
Willy Tarreau79e57332018-10-02 16:01:16 +0200474
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200475 if (!htx)
476 return 0;
477 temp = get_trash_chunk();
478 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
479 struct htx_blk *blk = htx_get_blk(htx, pos);
480 enum htx_blk_type type = htx_get_blk_type(blk);
Willy Tarreau79e57332018-10-02 16:01:16 +0200481
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200482 if (type == HTX_BLK_HDR) {
483 struct ist n = htx_get_blk_name(htx, blk);
484 struct ist v = htx_get_blk_value(htx, blk);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200485
Christopher Faulet53a899b2019-10-08 16:38:42 +0200486 if (!h1_format_htx_hdr(n, v, temp))
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200487 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200488 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200489 else if (type == HTX_BLK_EOH) {
490 if (!chunk_memcat(temp, "\r\n", 2))
491 return 0;
492 break;
493 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200494 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200495 smp->data.type = SMP_T_STR;
496 smp->data.u.str = *temp;
Willy Tarreau79e57332018-10-02 16:01:16 +0200497 return 1;
498}
499
500/* Returns the header request in a length/value encoded format.
501 * This is useful for exchanges with the SPOE.
502 *
503 * A "length value" is a multibyte code encoding numbers. It uses the
504 * SPOE format. The encoding is the following:
505 *
506 * Each couple "header name" / "header value" is composed
507 * like this:
508 * "length value" "header name bytes"
509 * "length value" "header value bytes"
510 * When the last header is reached, the header name and the header
511 * value are empty. Their length are 0
512 */
513static int smp_fetch_hdrs_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
514{
Christopher Faulete596d182020-05-05 17:46:34 +0200515 /* possible keywords: req.hdrs_bin, res.hdrs_bin */
516 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200517 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200518 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200519 struct buffer *temp;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200520 char *p, *end;
521 int32_t pos;
522 int ret;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200523
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200524 if (!htx)
525 return 0;
526 temp = get_trash_chunk();
527 p = temp->area;
528 end = temp->area + temp->size;
529 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
530 struct htx_blk *blk = htx_get_blk(htx, pos);
531 enum htx_blk_type type = htx_get_blk_type(blk);
532 struct ist n, v;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200533
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200534 if (type == HTX_BLK_HDR) {
535 n = htx_get_blk_name(htx,blk);
536 v = htx_get_blk_value(htx, blk);
Willy Tarreau79e57332018-10-02 16:01:16 +0200537
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200538 /* encode the header name. */
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200539 ret = encode_varint(n.len, &p, end);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200540 if (ret == -1)
541 return 0;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200542 if (p + n.len > end)
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200543 return 0;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200544 memcpy(p, n.ptr, n.len);
545 p += n.len;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200546
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200547 /* encode the header value. */
548 ret = encode_varint(v.len, &p, end);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200549 if (ret == -1)
550 return 0;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200551 if (p + v.len > end)
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200552 return 0;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200553 memcpy(p, v.ptr, v.len);
554 p += v.len;
Willy Tarreau79e57332018-10-02 16:01:16 +0200555
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200556 }
557 else if (type == HTX_BLK_EOH) {
558 /* encode the end of the header list with empty
559 * header name and header value.
560 */
561 ret = encode_varint(0, &p, end);
562 if (ret == -1)
563 return 0;
564 ret = encode_varint(0, &p, end);
565 if (ret == -1)
566 return 0;
567 break;
568 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200569 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200570
571 /* Initialise sample data which will be filled. */
572 smp->data.type = SMP_T_BIN;
573 smp->data.u.str.area = temp->area;
574 smp->data.u.str.data = p - temp->area;
575 smp->data.u.str.size = temp->size;
Willy Tarreau79e57332018-10-02 16:01:16 +0200576 return 1;
577}
578
579/* returns the longest available part of the body. This requires that the body
580 * has been waited for using http-buffer-request.
581 */
582static int smp_fetch_body(const struct arg *args, struct sample *smp, const char *kw, void *private)
583{
Christopher Faulete596d182020-05-05 17:46:34 +0200584 /* possible keywords: req.body, res.body */
585 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200586 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200587 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Willy Tarreau79e57332018-10-02 16:01:16 +0200588 struct buffer *temp;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200589 int32_t pos;
Willy Tarreau79e57332018-10-02 16:01:16 +0200590
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200591 if (!htx)
592 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200593
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200594 temp = get_trash_chunk();
595 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
596 struct htx_blk *blk = htx_get_blk(htx, pos);
597 enum htx_blk_type type = htx_get_blk_type(blk);
Willy Tarreau79e57332018-10-02 16:01:16 +0200598
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200599 if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT)
600 break;
601 if (type == HTX_BLK_DATA) {
Christopher Faulet53a899b2019-10-08 16:38:42 +0200602 if (!h1_format_htx_data(htx_get_blk_value(htx, blk), temp, 0))
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200603 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200604 }
Willy Tarreau79e57332018-10-02 16:01:16 +0200605 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200606
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200607 smp->data.type = SMP_T_BIN;
608 smp->data.u.str = *temp;
609 smp->flags = SMP_F_VOL_TEST;
Willy Tarreau9dc92b22020-06-15 18:01:10 +0200610
611 if (!channel_full(chn, global.tune.maxrewrite) && !(chn->flags & (CF_EOI|CF_SHUTR|CF_READ_ERROR)))
612 smp->flags |= SMP_F_MAY_CHANGE;
613
Willy Tarreau79e57332018-10-02 16:01:16 +0200614 return 1;
615}
616
617
618/* returns the available length of the body. This requires that the body
619 * has been waited for using http-buffer-request.
620 */
621static int smp_fetch_body_len(const struct arg *args, struct sample *smp, const char *kw, void *private)
622{
Christopher Faulete596d182020-05-05 17:46:34 +0200623 /* possible keywords: req.body_len, res.body_len */
624 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200625 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200626 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200627 int32_t pos;
628 unsigned long long len = 0;
Christopher Fauletc16317d2018-12-12 14:11:22 +0100629
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200630 if (!htx)
631 return 0;
Christopher Fauletc16317d2018-12-12 14:11:22 +0100632
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200633 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
634 struct htx_blk *blk = htx_get_blk(htx, pos);
635 enum htx_blk_type type = htx_get_blk_type(blk);
Christopher Fauletc16317d2018-12-12 14:11:22 +0100636
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200637 if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT)
638 break;
639 if (type == HTX_BLK_DATA)
640 len += htx_get_blksz(blk);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200641 }
Willy Tarreau79e57332018-10-02 16:01:16 +0200642
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200643 smp->data.type = SMP_T_SINT;
644 smp->data.u.sint = len;
645 smp->flags = SMP_F_VOL_TEST;
Willy Tarreau79e57332018-10-02 16:01:16 +0200646 return 1;
647}
648
649
650/* returns the advertised length of the body, or the advertised size of the
651 * chunks available in the buffer. This requires that the body has been waited
652 * for using http-buffer-request.
653 */
654static int smp_fetch_body_size(const struct arg *args, struct sample *smp, const char *kw, void *private)
655{
Christopher Faulete596d182020-05-05 17:46:34 +0200656 /* possible keywords: req.body_size, res.body_size */
657 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200658 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200659 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200660 int32_t pos;
661 unsigned long long len = 0;
Christopher Faulet89dc4992019-04-17 12:02:59 +0200662
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200663 if (!htx)
664 return 0;
Christopher Fauletc16317d2018-12-12 14:11:22 +0100665
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200666 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
667 struct htx_blk *blk = htx_get_blk(htx, pos);
668 enum htx_blk_type type = htx_get_blk_type(blk);
Christopher Fauletc16317d2018-12-12 14:11:22 +0100669
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200670 if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT)
671 break;
672 if (type == HTX_BLK_DATA)
673 len += htx_get_blksz(blk);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200674 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200675 if (htx->extra != ULLONG_MAX)
676 len += htx->extra;
Willy Tarreau79e57332018-10-02 16:01:16 +0200677
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200678 smp->data.type = SMP_T_SINT;
679 smp->data.u.sint = len;
680 smp->flags = SMP_F_VOL_TEST;
Willy Tarreau79e57332018-10-02 16:01:16 +0200681 return 1;
682}
683
684
685/* 4. Check on URL/URI. A pointer to the URI is stored. */
686static int smp_fetch_url(const struct arg *args, struct sample *smp, const char *kw, void *private)
687{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200688 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200689 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200690 struct htx_sl *sl;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200691
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200692 if (!htx)
693 return 0;
694 sl = http_get_stline(htx);
695 smp->data.type = SMP_T_STR;
696 smp->data.u.str.area = HTX_SL_REQ_UPTR(sl);
697 smp->data.u.str.data = HTX_SL_REQ_ULEN(sl);
698 smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
Willy Tarreau79e57332018-10-02 16:01:16 +0200699 return 1;
700}
701
702static int smp_fetch_url_ip(const struct arg *args, struct sample *smp, const char *kw, void *private)
703{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200704 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200705 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200706 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +0200707 struct sockaddr_storage addr;
708
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200709 if (!htx)
710 return 0;
711 sl = http_get_stline(htx);
712 url2sa(HTX_SL_REQ_UPTR(sl), HTX_SL_REQ_ULEN(sl), &addr, NULL);
Willy Tarreau79e57332018-10-02 16:01:16 +0200713
Willy Tarreau79e57332018-10-02 16:01:16 +0200714 if (((struct sockaddr_in *)&addr)->sin_family != AF_INET)
715 return 0;
716
717 smp->data.type = SMP_T_IPV4;
718 smp->data.u.ipv4 = ((struct sockaddr_in *)&addr)->sin_addr;
719 smp->flags = 0;
720 return 1;
721}
722
723static int smp_fetch_url_port(const struct arg *args, struct sample *smp, const char *kw, void *private)
724{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200725 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +0200726 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200727 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +0200728 struct sockaddr_storage addr;
729
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200730 if (!htx)
731 return 0;
732 sl = http_get_stline(htx);
733 url2sa(HTX_SL_REQ_UPTR(sl), HTX_SL_REQ_ULEN(sl), &addr, NULL);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200734
Willy Tarreau79e57332018-10-02 16:01:16 +0200735 if (((struct sockaddr_in *)&addr)->sin_family != AF_INET)
736 return 0;
737
738 smp->data.type = SMP_T_SINT;
739 smp->data.u.sint = ntohs(((struct sockaddr_in *)&addr)->sin_port);
740 smp->flags = 0;
741 return 1;
742}
743
744/* Fetch an HTTP header. A pointer to the beginning of the value is returned.
745 * Accepts an optional argument of type string containing the header field name,
746 * and an optional argument of type signed or unsigned integer to request an
747 * explicit occurrence of the header. Note that in the event of a missing name,
748 * headers are considered from the first one. It does not stop on commas and
749 * returns full lines instead (useful for User-Agent or Date for example).
750 */
751static int smp_fetch_fhdr(const struct arg *args, struct sample *smp, const char *kw, void *private)
752{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200753 /* possible keywords: req.fhdr, res.fhdr */
754 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200755 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200756 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200757 struct http_hdr_ctx *ctx = smp->ctx.a[0];
758 struct ist name;
Willy Tarreau79e57332018-10-02 16:01:16 +0200759 int occ = 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200760
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200761 if (!ctx) {
762 /* first call */
763 ctx = &static_http_hdr_ctx;
764 ctx->blk = NULL;
765 smp->ctx.a[0] = ctx;
766 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200767
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200768 if (args) {
769 if (args[0].type != ARGT_STR)
Willy Tarreau79e57332018-10-02 16:01:16 +0200770 return 0;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200771 name.ptr = args[0].data.str.area;
772 name.len = args[0].data.str.data;
Willy Tarreau79e57332018-10-02 16:01:16 +0200773
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200774 if (args[1].type == ARGT_SINT)
775 occ = args[1].data.sint;
Willy Tarreau79e57332018-10-02 16:01:16 +0200776 }
777
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200778 if (!htx)
779 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200780
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200781 if (ctx && !(smp->flags & SMP_F_NOT_LAST))
782 /* search for header from the beginning */
783 ctx->blk = NULL;
Willy Tarreau79e57332018-10-02 16:01:16 +0200784
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200785 if (!occ && !(smp->opt & SMP_OPT_ITERATE))
786 /* no explicit occurrence and single fetch => last header by default */
787 occ = -1;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200788
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200789 if (!occ)
790 /* prepare to report multiple occurrences for ACL fetches */
791 smp->flags |= SMP_F_NOT_LAST;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200792
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200793 smp->data.type = SMP_T_STR;
794 smp->flags |= SMP_F_VOL_HDR | SMP_F_CONST;
795 if (http_get_htx_fhdr(htx, name, occ, ctx, &smp->data.u.str.area, &smp->data.u.str.data))
796 return 1;
Willy Tarreau79e57332018-10-02 16:01:16 +0200797 smp->flags &= ~SMP_F_NOT_LAST;
798 return 0;
799}
800
801/* 6. Check on HTTP header count. The number of occurrences is returned.
802 * Accepts exactly 1 argument of type string. It does not stop on commas and
803 * returns full lines instead (useful for User-Agent or Date for example).
804 */
805static int smp_fetch_fhdr_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private)
806{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200807 /* possible keywords: req.fhdr_cnt, res.fhdr_cnt */
808 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200809 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200810 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200811 struct http_hdr_ctx ctx;
812 struct ist name;
Willy Tarreau79e57332018-10-02 16:01:16 +0200813 int cnt;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200814
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200815 if (!htx)
816 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200817
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200818 if (args && args->type == ARGT_STR) {
819 name.ptr = args->data.str.area;
820 name.len = args->data.str.data;
821 } else {
822 name.ptr = NULL;
823 name.len = 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200824 }
Willy Tarreau79e57332018-10-02 16:01:16 +0200825
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200826 ctx.blk = NULL;
827 cnt = 0;
828 while (http_find_header(htx, name, &ctx, 1))
829 cnt++;
Willy Tarreau79e57332018-10-02 16:01:16 +0200830 smp->data.type = SMP_T_SINT;
831 smp->data.u.sint = cnt;
832 smp->flags = SMP_F_VOL_HDR;
833 return 1;
834}
835
836static int smp_fetch_hdr_names(const struct arg *args, struct sample *smp, const char *kw, void *private)
837{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200838 /* possible keywords: req.hdr_names, res.hdr_names */
839 struct channel *chn = ((kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200840 struct check *check = ((kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200841 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Willy Tarreau79e57332018-10-02 16:01:16 +0200842 struct buffer *temp;
843 char del = ',';
844
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200845 int32_t pos;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200846
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200847 if (!htx)
848 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200849
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200850 if (args && args->type == ARGT_STR)
851 del = *args[0].data.str.area;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200852
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200853 temp = get_trash_chunk();
854 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
855 struct htx_blk *blk = htx_get_blk(htx, pos);
856 enum htx_blk_type type = htx_get_blk_type(blk);
857 struct ist n;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200858
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200859 if (type == HTX_BLK_EOH)
860 break;
861 if (type != HTX_BLK_HDR)
862 continue;
863 n = htx_get_blk_name(htx, blk);
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200864
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200865 if (temp->data)
866 temp->area[temp->data++] = del;
867 chunk_memcat(temp, n.ptr, n.len);
Willy Tarreau79e57332018-10-02 16:01:16 +0200868 }
869
870 smp->data.type = SMP_T_STR;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200871 smp->data.u.str = *temp;
Willy Tarreau79e57332018-10-02 16:01:16 +0200872 smp->flags = SMP_F_VOL_HDR;
873 return 1;
874}
875
876/* Fetch an HTTP header. A pointer to the beginning of the value is returned.
877 * Accepts an optional argument of type string containing the header field name,
878 * and an optional argument of type signed or unsigned integer to request an
879 * explicit occurrence of the header. Note that in the event of a missing name,
880 * headers are considered from the first one.
881 */
882static int smp_fetch_hdr(const struct arg *args, struct sample *smp, const char *kw, void *private)
883{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200884 /* possible keywords: req.hdr / hdr, res.hdr / shdr */
885 struct channel *chn = ((kw[0] == 'h' || kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200886 struct check *check = ((kw[0] == 's' || kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200887 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200888 struct http_hdr_ctx *ctx = smp->ctx.a[0];
889 struct ist name;
Willy Tarreau79e57332018-10-02 16:01:16 +0200890 int occ = 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200891
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200892 if (!ctx) {
893 /* first call */
894 ctx = &static_http_hdr_ctx;
895 ctx->blk = NULL;
896 smp->ctx.a[0] = ctx;
897 }
Willy Tarreau79e57332018-10-02 16:01:16 +0200898
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200899 if (args) {
900 if (args[0].type != ARGT_STR)
Willy Tarreau79e57332018-10-02 16:01:16 +0200901 return 0;
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200902 name.ptr = args[0].data.str.area;
903 name.len = args[0].data.str.data;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200904
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200905 if (args[1].type == ARGT_SINT)
906 occ = args[1].data.sint;
Willy Tarreau79e57332018-10-02 16:01:16 +0200907 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200908
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200909 if (!htx)
910 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200911
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200912 if (ctx && !(smp->flags & SMP_F_NOT_LAST))
913 /* search for header from the beginning */
914 ctx->blk = NULL;
Willy Tarreau79e57332018-10-02 16:01:16 +0200915
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200916 if (!occ && !(smp->opt & SMP_OPT_ITERATE))
917 /* no explicit occurrence and single fetch => last header by default */
918 occ = -1;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200919
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200920 if (!occ)
921 /* prepare to report multiple occurrences for ACL fetches */
922 smp->flags |= SMP_F_NOT_LAST;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200923
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200924 smp->data.type = SMP_T_STR;
925 smp->flags |= SMP_F_VOL_HDR | SMP_F_CONST;
926 if (http_get_htx_hdr(htx, name, occ, ctx, &smp->data.u.str.area, &smp->data.u.str.data))
927 return 1;
Willy Tarreau79e57332018-10-02 16:01:16 +0200928
929 smp->flags &= ~SMP_F_NOT_LAST;
930 return 0;
931}
932
Christopher Fauletc1f40dd2019-05-16 10:07:30 +0200933/* Same than smp_fetch_hdr() but only relies on the sample direction to choose
934 * the right channel. So instead of duplicating the code, we just change the
935 * keyword and then fallback on smp_fetch_hdr().
936 */
937static int smp_fetch_chn_hdr(const struct arg *args, struct sample *smp, const char *kw, void *private)
938{
939 kw = ((smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ ? "req.hdr" : "res.hdr");
940 return smp_fetch_hdr(args, smp, kw, private);
941}
942
Willy Tarreau79e57332018-10-02 16:01:16 +0200943/* 6. Check on HTTP header count. The number of occurrences is returned.
944 * Accepts exactly 1 argument of type string.
945 */
946static int smp_fetch_hdr_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private)
947{
Christopher Faulet89dc4992019-04-17 12:02:59 +0200948 /* possible keywords: req.hdr_cnt / hdr_cnt, res.hdr_cnt / shdr_cnt */
949 struct channel *chn = ((kw[0] == 'h' || kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +0200950 struct check *check = ((kw[0] == 's' || kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +0200951 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200952 struct http_hdr_ctx ctx;
953 struct ist name;
Willy Tarreau79e57332018-10-02 16:01:16 +0200954 int cnt;
Christopher Faulet311c7ea2018-10-24 21:41:55 +0200955
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200956 if (!htx)
957 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200958
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200959 if (args && args->type == ARGT_STR) {
960 name.ptr = args->data.str.area;
961 name.len = args->data.str.data;
962 } else {
963 name.ptr = NULL;
964 name.len = 0;
Willy Tarreau79e57332018-10-02 16:01:16 +0200965 }
Willy Tarreau79e57332018-10-02 16:01:16 +0200966
Christopher Faulet6d1dd462019-07-15 14:36:03 +0200967 ctx.blk = NULL;
968 cnt = 0;
969 while (http_find_header(htx, name, &ctx, 0))
970 cnt++;
Willy Tarreau79e57332018-10-02 16:01:16 +0200971
972 smp->data.type = SMP_T_SINT;
973 smp->data.u.sint = cnt;
974 smp->flags = SMP_F_VOL_HDR;
975 return 1;
976}
977
978/* Fetch an HTTP header's integer value. The integer value is returned. It
979 * takes a mandatory argument of type string and an optional one of type int
980 * to designate a specific occurrence. It returns an unsigned integer, which
981 * may or may not be appropriate for everything.
982 */
983static int smp_fetch_hdr_val(const struct arg *args, struct sample *smp, const char *kw, void *private)
984{
985 int ret = smp_fetch_hdr(args, smp, kw, private);
986
987 if (ret > 0) {
988 smp->data.type = SMP_T_SINT;
989 smp->data.u.sint = strl2ic(smp->data.u.str.area,
990 smp->data.u.str.data);
991 }
992
993 return ret;
994}
995
996/* Fetch an HTTP header's IP value. takes a mandatory argument of type string
997 * and an optional one of type int to designate a specific occurrence.
998 * It returns an IPv4 or IPv6 address.
999 */
1000static int smp_fetch_hdr_ip(const struct arg *args, struct sample *smp, const char *kw, void *private)
1001{
1002 int ret;
Tim Duesterhus5cd00872020-06-26 15:44:48 +02001003 struct buffer *temp = get_trash_chunk();
Willy Tarreau79e57332018-10-02 16:01:16 +02001004
1005 while ((ret = smp_fetch_hdr(args, smp, kw, private)) > 0) {
Tim Duesterhus5cd00872020-06-26 15:44:48 +02001006 if (smp->data.u.str.data < temp->size - 1) {
1007 memcpy(temp->area, smp->data.u.str.area,
1008 smp->data.u.str.data);
1009 temp->area[smp->data.u.str.data] = '\0';
1010 if (url2ipv4((char *) temp->area, &smp->data.u.ipv4)) {
1011 smp->data.type = SMP_T_IPV4;
1012 break;
1013 } else if (inet_pton(AF_INET6, temp->area, &smp->data.u.ipv6)) {
1014 smp->data.type = SMP_T_IPV6;
1015 break;
Willy Tarreau79e57332018-10-02 16:01:16 +02001016 }
1017 }
1018
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001019 /* if the header doesn't match an IP address, fetch next one */
1020 if (!(smp->flags & SMP_F_NOT_LAST))
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001021 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001022 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001023 return ret;
1024}
Willy Tarreau79e57332018-10-02 16:01:16 +02001025
Christopher Faulete720c322020-09-02 17:25:18 +02001026/* 8. Check on URI PATH. A pointer to the PATH is stored. The path starts at the
1027 * first '/' after the possible hostname. It ends before the possible '?' except
1028 * for 'pathq' keyword.
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001029 */
1030static int smp_fetch_path(const struct arg *args, struct sample *smp, const char *kw, void *private)
1031{
1032 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001033 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001034 struct htx_sl *sl;
1035 struct ist path;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001036
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001037 if (!htx)
1038 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001039
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001040 sl = http_get_stline(htx);
Christopher Faulete720c322020-09-02 17:25:18 +02001041 path = http_get_path(htx_sl_req_uri(sl));
1042
1043 if (kw[0] == 'p' && kw[4] == 'q') // pathq
1044 path = http_get_path(htx_sl_req_uri(sl));
1045 else
1046 path = iststop(http_get_path(htx_sl_req_uri(sl)), '?');
1047
Tim Duesterhused526372020-03-05 17:56:33 +01001048 if (!isttest(path))
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001049 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001050
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001051 /* OK, we got the '/' ! */
1052 smp->data.type = SMP_T_STR;
1053 smp->data.u.str.area = path.ptr;
Jerome Magnin4fb196c2020-02-21 10:49:12 +01001054 smp->data.u.str.data = path.len;
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001055 smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
Willy Tarreau79e57332018-10-02 16:01:16 +02001056 return 1;
1057}
1058
1059/* This produces a concatenation of the first occurrence of the Host header
1060 * followed by the path component if it begins with a slash ('/'). This means
1061 * that '*' will not be added, resulting in exactly the first Host entry.
1062 * If no Host header is found, then the path is returned as-is. The returned
1063 * value is stored in the trash so it does not need to be marked constant.
1064 * The returned sample is of type string.
1065 */
1066static int smp_fetch_base(const struct arg *args, struct sample *smp, const char *kw, void *private)
1067{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001068 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001069 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001070 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +02001071 struct buffer *temp;
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001072 struct http_hdr_ctx ctx;
1073 struct ist path;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001074
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001075 if (!htx)
1076 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001077
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001078 ctx.blk = NULL;
1079 if (!http_find_header(htx, ist("Host"), &ctx, 0) || !ctx.value.len)
1080 return smp_fetch_path(args, smp, kw, private);
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001081
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001082 /* OK we have the header value in ctx.value */
1083 temp = get_trash_chunk();
1084 chunk_memcat(temp, ctx.value.ptr, ctx.value.len);
Willy Tarreau79e57332018-10-02 16:01:16 +02001085
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001086 /* now retrieve the path */
1087 sl = http_get_stline(htx);
1088 path = http_get_path(htx_sl_req_uri(sl));
Tim Duesterhused526372020-03-05 17:56:33 +01001089 if (isttest(path)) {
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001090 size_t len;
Willy Tarreau79e57332018-10-02 16:01:16 +02001091
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001092 for (len = 0; len < path.len && *(path.ptr + len) != '?'; len++)
1093 ;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001094
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001095 if (len && *(path.ptr) == '/')
1096 chunk_memcat(temp, path.ptr, len);
Willy Tarreau79e57332018-10-02 16:01:16 +02001097 }
1098
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001099 smp->data.type = SMP_T_STR;
1100 smp->data.u.str = *temp;
Willy Tarreau79e57332018-10-02 16:01:16 +02001101 smp->flags = SMP_F_VOL_1ST;
1102 return 1;
1103}
1104
1105/* This produces a 32-bit hash of the concatenation of the first occurrence of
1106 * the Host header followed by the path component if it begins with a slash ('/').
1107 * This means that '*' will not be added, resulting in exactly the first Host
1108 * entry. If no Host header is found, then the path is used. The resulting value
1109 * is hashed using the path hash followed by a full avalanche hash and provides a
1110 * 32-bit integer value. This fetch is useful for tracking per-path activity on
1111 * high-traffic sites without having to store whole paths.
1112 */
1113static int smp_fetch_base32(const struct arg *args, struct sample *smp, const char *kw, void *private)
1114{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001115 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001116 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001117 struct htx_sl *sl;
1118 struct http_hdr_ctx ctx;
1119 struct ist path;
Willy Tarreau79e57332018-10-02 16:01:16 +02001120 unsigned int hash = 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001121
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001122 if (!htx)
1123 return 0;
Dragan Dosen8861e1c2019-02-12 19:50:31 +01001124
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001125 ctx.blk = NULL;
1126 if (http_find_header(htx, ist("Host"), &ctx, 0)) {
1127 /* OK we have the header value in ctx.value */
1128 while (ctx.value.len--)
1129 hash = *(ctx.value.ptr++) + (hash << 6) + (hash << 16) - hash;
Willy Tarreau79e57332018-10-02 16:01:16 +02001130 }
1131
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001132 /* now retrieve the path */
1133 sl = http_get_stline(htx);
1134 path = http_get_path(htx_sl_req_uri(sl));
Tim Duesterhused526372020-03-05 17:56:33 +01001135 if (isttest(path)) {
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001136 size_t len;
Willy Tarreau79e57332018-10-02 16:01:16 +02001137
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001138 for (len = 0; len < path.len && *(path.ptr + len) != '?'; len++)
1139 ;
Willy Tarreau79e57332018-10-02 16:01:16 +02001140
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001141 if (len && *(path.ptr) == '/') {
1142 while (len--)
1143 hash = *(path.ptr++) + (hash << 6) + (hash << 16) - hash;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001144 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001145 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001146
Willy Tarreau79e57332018-10-02 16:01:16 +02001147 hash = full_hash(hash);
1148
1149 smp->data.type = SMP_T_SINT;
1150 smp->data.u.sint = hash;
1151 smp->flags = SMP_F_VOL_1ST;
1152 return 1;
1153}
1154
1155/* This concatenates the source address with the 32-bit hash of the Host and
1156 * path as returned by smp_fetch_base32(). The idea is to have per-source and
1157 * per-path counters. The result is a binary block from 8 to 20 bytes depending
1158 * on the source address length. The path hash is stored before the address so
1159 * that in environments where IPv6 is insignificant, truncating the output to
1160 * 8 bytes would still work.
1161 */
1162static int smp_fetch_base32_src(const struct arg *args, struct sample *smp, const char *kw, void *private)
1163{
1164 struct buffer *temp;
1165 struct connection *cli_conn = objt_conn(smp->sess->origin);
1166
Willy Tarreaucd7ca792019-07-17 16:57:03 +02001167 if (!cli_conn || !conn_get_src(cli_conn))
Willy Tarreau79e57332018-10-02 16:01:16 +02001168 return 0;
1169
1170 if (!smp_fetch_base32(args, smp, kw, private))
1171 return 0;
1172
1173 temp = get_trash_chunk();
1174 *(unsigned int *) temp->area = htonl(smp->data.u.sint);
1175 temp->data += sizeof(unsigned int);
1176
Willy Tarreau9a1efe12019-07-17 17:13:50 +02001177 switch (cli_conn->src->ss_family) {
Willy Tarreau79e57332018-10-02 16:01:16 +02001178 case AF_INET:
1179 memcpy(temp->area + temp->data,
Willy Tarreau9a1efe12019-07-17 17:13:50 +02001180 &((struct sockaddr_in *)cli_conn->src)->sin_addr,
Willy Tarreau79e57332018-10-02 16:01:16 +02001181 4);
1182 temp->data += 4;
1183 break;
1184 case AF_INET6:
1185 memcpy(temp->area + temp->data,
Willy Tarreau9a1efe12019-07-17 17:13:50 +02001186 &((struct sockaddr_in6 *)cli_conn->src)->sin6_addr,
Willy Tarreau79e57332018-10-02 16:01:16 +02001187 16);
1188 temp->data += 16;
1189 break;
1190 default:
1191 return 0;
1192 }
1193
1194 smp->data.u.str = *temp;
1195 smp->data.type = SMP_T_BIN;
1196 return 1;
1197}
1198
1199/* Extracts the query string, which comes after the question mark '?'. If no
1200 * question mark is found, nothing is returned. Otherwise it returns a sample
1201 * of type string carrying the whole query string.
1202 */
1203static int smp_fetch_query(const struct arg *args, struct sample *smp, const char *kw, void *private)
1204{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001205 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001206 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001207 struct htx_sl *sl;
Willy Tarreau79e57332018-10-02 16:01:16 +02001208 char *ptr, *end;
1209
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001210 if (!htx)
1211 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001212
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001213 sl = http_get_stline(htx);
1214 ptr = HTX_SL_REQ_UPTR(sl);
1215 end = HTX_SL_REQ_UPTR(sl) + HTX_SL_REQ_ULEN(sl);
Willy Tarreau79e57332018-10-02 16:01:16 +02001216
1217 /* look up the '?' */
1218 do {
1219 if (ptr == end)
1220 return 0;
1221 } while (*ptr++ != '?');
1222
1223 smp->data.type = SMP_T_STR;
1224 smp->data.u.str.area = ptr;
1225 smp->data.u.str.data = end - ptr;
1226 smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
1227 return 1;
1228}
1229
1230static int smp_fetch_proto_http(const struct arg *args, struct sample *smp, const char *kw, void *private)
1231{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001232 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001233 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 0);
Willy Tarreau79e57332018-10-02 16:01:16 +02001234
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001235 if (!htx)
1236 return 0;
1237 smp->data.type = SMP_T_BOOL;
Willy Tarreau79e57332018-10-02 16:01:16 +02001238 smp->data.u.sint = 1;
1239 return 1;
1240}
1241
1242/* return a valid test if the current request is the first one on the connection */
1243static int smp_fetch_http_first_req(const struct arg *args, struct sample *smp, const char *kw, void *private)
1244{
Willy Tarreau79512b62020-04-29 11:52:13 +02001245 if (!smp->strm)
1246 return 0;
1247
Willy Tarreau79e57332018-10-02 16:01:16 +02001248 smp->data.type = SMP_T_BOOL;
1249 smp->data.u.sint = !(smp->strm->txn->flags & TX_NOT_FIRST);
1250 return 1;
1251}
1252
Christopher Fauleta4063562019-08-02 11:51:37 +02001253/* Fetch the authentication method if there is an Authorization header. It
1254 * relies on get_http_auth()
1255 */
1256static int smp_fetch_http_auth_type(const struct arg *args, struct sample *smp, const char *kw, void *private)
1257{
1258 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001259 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Fauleta4063562019-08-02 11:51:37 +02001260 struct http_txn *txn;
1261
1262 if (!htx)
1263 return 0;
1264
1265 txn = smp->strm->txn;
1266 if (!get_http_auth(smp, htx))
1267 return 0;
1268
1269 switch (txn->auth.method) {
1270 case HTTP_AUTH_BASIC:
1271 smp->data.u.str.area = "Basic";
1272 smp->data.u.str.data = 5;
1273 break;
1274 case HTTP_AUTH_DIGEST:
1275 /* Unexpected because not supported */
1276 smp->data.u.str.area = "Digest";
1277 smp->data.u.str.data = 6;
1278 break;
1279 default:
1280 return 0;
1281 }
1282
1283 smp->data.type = SMP_T_STR;
1284 smp->flags = SMP_F_CONST;
1285 return 1;
1286}
1287
1288/* Fetch the user supplied if there is an Authorization header. It relies on
1289 * get_http_auth()
1290 */
1291static int smp_fetch_http_auth_user(const struct arg *args, struct sample *smp, const char *kw, void *private)
1292{
1293 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001294 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Fauleta4063562019-08-02 11:51:37 +02001295 struct http_txn *txn;
1296
1297 if (!htx)
1298 return 0;
1299
1300 txn = smp->strm->txn;
1301 if (!get_http_auth(smp, htx))
1302 return 0;
1303
1304 smp->data.type = SMP_T_STR;
1305 smp->data.u.str.area = txn->auth.user;
1306 smp->data.u.str.data = strlen(txn->auth.user);
1307 smp->flags = SMP_F_CONST;
1308 return 1;
1309}
1310
1311/* Fetch the password supplied if there is an Authorization header. It relies on
1312 * get_http_auth()
1313 */
1314static int smp_fetch_http_auth_pass(const struct arg *args, struct sample *smp, const char *kw, void *private)
1315{
1316 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001317 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Fauleta4063562019-08-02 11:51:37 +02001318 struct http_txn *txn;
1319
1320 if (!htx)
1321 return 0;
1322
1323 txn = smp->strm->txn;
1324 if (!get_http_auth(smp, htx))
1325 return 0;
1326
1327 smp->data.type = SMP_T_STR;
1328 smp->data.u.str.area = txn->auth.pass;
1329 smp->data.u.str.data = strlen(txn->auth.pass);
1330 smp->flags = SMP_F_CONST;
1331 return 1;
1332}
1333
Willy Tarreau79e57332018-10-02 16:01:16 +02001334/* Accepts exactly 1 argument of type userlist */
1335static int smp_fetch_http_auth(const struct arg *args, struct sample *smp, const char *kw, void *private)
1336{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001337 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001338 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Willy Tarreau79e57332018-10-02 16:01:16 +02001339
1340 if (!args || args->type != ARGT_USR)
1341 return 0;
1342
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001343 if (!htx)
1344 return 0;
1345 if (!get_http_auth(smp, htx))
1346 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001347
1348 smp->data.type = SMP_T_BOOL;
1349 smp->data.u.sint = check_user(args->data.usr, smp->strm->txn->auth.user,
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001350 smp->strm->txn->auth.pass);
Willy Tarreau79e57332018-10-02 16:01:16 +02001351 return 1;
1352}
1353
1354/* Accepts exactly 1 argument of type userlist */
1355static int smp_fetch_http_auth_grp(const struct arg *args, struct sample *smp, const char *kw, void *private)
1356{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001357 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001358 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet89dc4992019-04-17 12:02:59 +02001359
Willy Tarreau79e57332018-10-02 16:01:16 +02001360 if (!args || args->type != ARGT_USR)
1361 return 0;
1362
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001363 if (!htx)
1364 return 0;
1365 if (!get_http_auth(smp, htx))
1366 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001367
Willy Tarreau79e57332018-10-02 16:01:16 +02001368 /* if the user does not belong to the userlist or has a wrong password,
1369 * report that it unconditionally does not match. Otherwise we return
1370 * a string containing the username.
1371 */
1372 if (!check_user(args->data.usr, smp->strm->txn->auth.user,
1373 smp->strm->txn->auth.pass))
1374 return 0;
1375
1376 /* pat_match_auth() will need the user list */
1377 smp->ctx.a[0] = args->data.usr;
1378
1379 smp->data.type = SMP_T_STR;
1380 smp->flags = SMP_F_CONST;
1381 smp->data.u.str.area = smp->strm->txn->auth.user;
1382 smp->data.u.str.data = strlen(smp->strm->txn->auth.user);
1383
1384 return 1;
1385}
1386
1387/* Fetch a captured HTTP request header. The index is the position of
1388 * the "capture" option in the configuration file
1389 */
1390static int smp_fetch_capture_req_hdr(const struct arg *args, struct sample *smp, const char *kw, void *private)
1391{
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001392 struct proxy *fe;
Willy Tarreau79e57332018-10-02 16:01:16 +02001393 int idx;
1394
1395 if (!args || args->type != ARGT_SINT)
1396 return 0;
1397
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001398 if (!smp->strm)
1399 return 0;
1400
1401 fe = strm_fe(smp->strm);
Willy Tarreau79e57332018-10-02 16:01:16 +02001402 idx = args->data.sint;
1403
1404 if (idx > (fe->nb_req_cap - 1) || smp->strm->req_cap == NULL || smp->strm->req_cap[idx] == NULL)
1405 return 0;
1406
1407 smp->data.type = SMP_T_STR;
1408 smp->flags |= SMP_F_CONST;
1409 smp->data.u.str.area = smp->strm->req_cap[idx];
1410 smp->data.u.str.data = strlen(smp->strm->req_cap[idx]);
1411
1412 return 1;
1413}
1414
1415/* Fetch a captured HTTP response header. The index is the position of
1416 * the "capture" option in the configuration file
1417 */
1418static int smp_fetch_capture_res_hdr(const struct arg *args, struct sample *smp, const char *kw, void *private)
1419{
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001420 struct proxy *fe;
Willy Tarreau79e57332018-10-02 16:01:16 +02001421 int idx;
1422
1423 if (!args || args->type != ARGT_SINT)
1424 return 0;
1425
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001426 if (!smp->strm)
1427 return 0;
1428
1429 fe = strm_fe(smp->strm);
Willy Tarreau79e57332018-10-02 16:01:16 +02001430 idx = args->data.sint;
1431
1432 if (idx > (fe->nb_rsp_cap - 1) || smp->strm->res_cap == NULL || smp->strm->res_cap[idx] == NULL)
1433 return 0;
1434
1435 smp->data.type = SMP_T_STR;
1436 smp->flags |= SMP_F_CONST;
1437 smp->data.u.str.area = smp->strm->res_cap[idx];
1438 smp->data.u.str.data = strlen(smp->strm->res_cap[idx]);
1439
1440 return 1;
1441}
1442
1443/* Extracts the METHOD in the HTTP request, the txn->uri should be filled before the call */
1444static int smp_fetch_capture_req_method(const struct arg *args, struct sample *smp, const char *kw, void *private)
1445{
1446 struct buffer *temp;
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001447 struct http_txn *txn;
Willy Tarreau79e57332018-10-02 16:01:16 +02001448 char *ptr;
1449
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001450 if (!smp->strm)
1451 return 0;
1452
1453 txn = smp->strm->txn;
Willy Tarreau79e57332018-10-02 16:01:16 +02001454 if (!txn || !txn->uri)
1455 return 0;
1456
1457 ptr = txn->uri;
1458
1459 while (*ptr != ' ' && *ptr != '\0') /* find first space */
1460 ptr++;
1461
1462 temp = get_trash_chunk();
1463 temp->area = txn->uri;
1464 temp->data = ptr - txn->uri;
1465 smp->data.u.str = *temp;
1466 smp->data.type = SMP_T_STR;
1467 smp->flags = SMP_F_CONST;
1468
1469 return 1;
1470
1471}
1472
1473/* Extracts the path in the HTTP request, the txn->uri should be filled before the call */
1474static int smp_fetch_capture_req_uri(const struct arg *args, struct sample *smp, const char *kw, void *private)
1475{
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001476 struct http_txn *txn;
Willy Tarreau79e57332018-10-02 16:01:16 +02001477 struct ist path;
1478 const char *ptr;
1479
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001480 if (!smp->strm)
1481 return 0;
1482
1483 txn = smp->strm->txn;
Willy Tarreau79e57332018-10-02 16:01:16 +02001484 if (!txn || !txn->uri)
1485 return 0;
1486
1487 ptr = txn->uri;
1488
1489 while (*ptr != ' ' && *ptr != '\0') /* find first space */
1490 ptr++;
1491
1492 if (!*ptr)
1493 return 0;
1494
Christopher Faulet78337bb2018-11-15 14:35:18 +01001495 /* skip the first space and find space after URI */
1496 path = ist2(++ptr, 0);
1497 while (*ptr != ' ' && *ptr != '\0')
1498 ptr++;
1499 path.len = ptr - path.ptr;
Willy Tarreau79e57332018-10-02 16:01:16 +02001500
Christopher Faulet78337bb2018-11-15 14:35:18 +01001501 path = http_get_path(path);
Tim Duesterhused526372020-03-05 17:56:33 +01001502 if (!isttest(path))
Willy Tarreau79e57332018-10-02 16:01:16 +02001503 return 0;
1504
1505 smp->data.u.str.area = path.ptr;
1506 smp->data.u.str.data = path.len;
1507 smp->data.type = SMP_T_STR;
1508 smp->flags = SMP_F_CONST;
1509
1510 return 1;
1511}
1512
1513/* Retrieves the HTTP version from the request (either 1.0 or 1.1) and emits it
1514 * as a string (either "HTTP/1.0" or "HTTP/1.1").
1515 */
1516static int smp_fetch_capture_req_ver(const struct arg *args, struct sample *smp, const char *kw, void *private)
1517{
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001518 struct http_txn *txn;
1519
1520 if (!smp->strm)
1521 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001522
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001523 txn = smp->strm->txn;
Christopher Faulet711ed6a2019-07-16 14:16:10 +02001524 if (!txn || txn->req.msg_state >= HTTP_MSG_BODY)
Willy Tarreau79e57332018-10-02 16:01:16 +02001525 return 0;
1526
1527 if (txn->req.flags & HTTP_MSGF_VER_11)
1528 smp->data.u.str.area = "HTTP/1.1";
1529 else
1530 smp->data.u.str.area = "HTTP/1.0";
1531
1532 smp->data.u.str.data = 8;
1533 smp->data.type = SMP_T_STR;
1534 smp->flags = SMP_F_CONST;
1535 return 1;
1536
1537}
1538
1539/* Retrieves the HTTP version from the response (either 1.0 or 1.1) and emits it
1540 * as a string (either "HTTP/1.0" or "HTTP/1.1").
1541 */
1542static int smp_fetch_capture_res_ver(const struct arg *args, struct sample *smp, const char *kw, void *private)
1543{
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001544 struct http_txn *txn;
1545
1546 if (!smp->strm)
1547 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001548
Willy Tarreau0898c2d2020-04-29 11:44:54 +02001549 txn = smp->strm->txn;
Christopher Faulet711ed6a2019-07-16 14:16:10 +02001550 if (!txn || txn->rsp.msg_state >= HTTP_MSG_BODY)
Willy Tarreau79e57332018-10-02 16:01:16 +02001551 return 0;
1552
1553 if (txn->rsp.flags & HTTP_MSGF_VER_11)
1554 smp->data.u.str.area = "HTTP/1.1";
1555 else
1556 smp->data.u.str.area = "HTTP/1.0";
1557
1558 smp->data.u.str.data = 8;
1559 smp->data.type = SMP_T_STR;
1560 smp->flags = SMP_F_CONST;
1561 return 1;
1562
1563}
1564
1565/* Iterate over all cookies present in a message. The context is stored in
1566 * smp->ctx.a[0] for the in-header position, smp->ctx.a[1] for the
1567 * end-of-header-value, and smp->ctx.a[2] for the hdr_ctx. Depending on
1568 * the direction, multiple cookies may be parsed on the same line or not.
Maciej Zdebdea7c202020-11-13 09:38:06 +00001569 * If provided, the searched cookie name is in args, in args->data.str. If
1570 * the input options indicate that no iterating is desired, then only last
1571 * value is fetched if any. If no cookie name is provided, the first cookie
1572 * value found is fetched. The returned sample is of type CSTR. Can be used
1573 * to parse cookies in other files.
Willy Tarreau79e57332018-10-02 16:01:16 +02001574 */
1575static int smp_fetch_cookie(const struct arg *args, struct sample *smp, const char *kw, void *private)
1576{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001577 /* possible keywords: req.cookie / cookie / cook, res.cookie / scook / set-cookie */
1578 struct channel *chn = ((kw[0] == 'c' || kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +02001579 struct check *check = ((kw[0] == 's' || kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +02001580 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001581 struct http_hdr_ctx *ctx = smp->ctx.a[2];
1582 struct ist hdr;
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001583 char *cook = NULL;
1584 size_t cook_l = 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001585 int found = 0;
1586
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001587 if (args && args->type == ARGT_STR) {
1588 cook = args->data.str.area;
1589 cook_l = args->data.str.data;
1590 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001591
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001592 if (!ctx) {
1593 /* first call */
1594 ctx = &static_http_hdr_ctx;
1595 ctx->blk = NULL;
1596 smp->ctx.a[2] = ctx;
1597 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001598
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001599 if (!htx)
1600 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001601
Christopher Faulet16032ab2020-04-30 11:30:00 +02001602 hdr = (!(check || (chn && chn->flags & CF_ISRESP)) ? ist("Cookie") : ist("Set-Cookie"));
Willy Tarreau79e57332018-10-02 16:01:16 +02001603
Maciej Zdebdea7c202020-11-13 09:38:06 +00001604 /* OK so basically here, either we want only one value or we want to
1605 * iterate over all of them and we fetch the next one. In this last case
1606 * SMP_OPT_ITERATE option is set.
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001607 */
Willy Tarreau79e57332018-10-02 16:01:16 +02001608
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001609 if (!(smp->flags & SMP_F_NOT_LAST)) {
1610 /* search for the header from the beginning, we must first initialize
1611 * the search parameters.
Willy Tarreau79e57332018-10-02 16:01:16 +02001612 */
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001613 smp->ctx.a[0] = NULL;
1614 ctx->blk = NULL;
Willy Tarreau79e57332018-10-02 16:01:16 +02001615 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001616
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001617 smp->flags |= SMP_F_VOL_HDR;
1618 while (1) {
1619 /* Note: smp->ctx.a[0] == NULL every time we need to fetch a new header */
1620 if (!smp->ctx.a[0]) {
1621 if (!http_find_header(htx, hdr, ctx, 0))
1622 goto out;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001623
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001624 if (ctx->value.len < cook_l + 1)
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001625 continue;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001626
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001627 smp->ctx.a[0] = ctx->value.ptr;
1628 smp->ctx.a[1] = smp->ctx.a[0] + ctx->value.len;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001629 }
1630
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001631 smp->data.type = SMP_T_STR;
1632 smp->flags |= SMP_F_CONST;
1633 smp->ctx.a[0] = http_extract_cookie_value(smp->ctx.a[0], smp->ctx.a[1],
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001634 cook, cook_l,
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001635 (smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ,
1636 &smp->data.u.str.area,
1637 &smp->data.u.str.data);
1638 if (smp->ctx.a[0]) {
1639 found = 1;
Maciej Zdebdea7c202020-11-13 09:38:06 +00001640 if (smp->opt & SMP_OPT_ITERATE) {
1641 /* iterate on cookie value */
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001642 smp->flags |= SMP_F_NOT_LAST;
1643 return 1;
Willy Tarreau79e57332018-10-02 16:01:16 +02001644 }
Maciej Zdebdea7c202020-11-13 09:38:06 +00001645 if (args->data.str.data == 0) {
1646 /* No cookie name, first occurrence returned */
1647 break;
1648 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001649 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001650 /* if we're looking for last occurrence, let's loop */
Willy Tarreau79e57332018-10-02 16:01:16 +02001651 }
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001652
Willy Tarreau79e57332018-10-02 16:01:16 +02001653 /* all cookie headers and values were scanned. If we're looking for the
1654 * last occurrence, we may return it now.
1655 */
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001656 out:
Willy Tarreau79e57332018-10-02 16:01:16 +02001657 smp->flags &= ~SMP_F_NOT_LAST;
1658 return found;
1659}
1660
Christopher Fauletc1f40dd2019-05-16 10:07:30 +02001661/* Same than smp_fetch_cookie() but only relies on the sample direction to
1662 * choose the right channel. So instead of duplicating the code, we just change
1663 * the keyword and then fallback on smp_fetch_cookie().
1664 */
1665static int smp_fetch_chn_cookie(const struct arg *args, struct sample *smp, const char *kw, void *private)
1666{
1667 kw = ((smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ ? "req.cook" : "res.cook");
1668 return smp_fetch_cookie(args, smp, kw, private);
1669}
1670
Willy Tarreau79e57332018-10-02 16:01:16 +02001671/* Iterate over all cookies present in a request to count how many occurrences
1672 * match the name in args and args->data.str.len. If <multi> is non-null, then
1673 * multiple cookies may be parsed on the same line. The returned sample is of
1674 * type UINT. Accepts exactly 1 argument of type string.
1675 */
1676static int smp_fetch_cookie_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private)
1677{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001678 /* possible keywords: req.cook_cnt / cook_cnt, res.cook_cnt / scook_cnt */
1679 struct channel *chn = ((kw[0] == 'c' || kw[2] == 'q') ? SMP_REQ_CHN(smp) : SMP_RES_CHN(smp));
Christopher Fauletf98e6262020-05-06 09:42:04 +02001680 struct check *check = ((kw[0] == 's' || kw[2] == 's') ? objt_check(smp->sess->origin) : NULL);
Christopher Faulet16032ab2020-04-30 11:30:00 +02001681 struct htx *htx = smp_prefetch_htx(smp, chn, check, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001682 struct http_hdr_ctx ctx;
1683 struct ist hdr;
Willy Tarreau79e57332018-10-02 16:01:16 +02001684 char *val_beg, *val_end;
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001685 char *cook = NULL;
1686 size_t cook_l = 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001687 int cnt;
Willy Tarreau79e57332018-10-02 16:01:16 +02001688
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001689 if (args && args->type == ARGT_STR){
1690 cook = args->data.str.area;
1691 cook_l = args->data.str.data;
1692 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001693
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001694 if (!htx)
1695 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001696
Christopher Faulet16032ab2020-04-30 11:30:00 +02001697 hdr = (!(check || (chn && chn->flags & CF_ISRESP)) ? ist("Cookie") : ist("Set-Cookie"));
Willy Tarreau79e57332018-10-02 16:01:16 +02001698
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001699 val_end = val_beg = NULL;
1700 ctx.blk = NULL;
1701 cnt = 0;
1702 while (1) {
1703 /* Note: val_beg == NULL every time we need to fetch a new header */
1704 if (!val_beg) {
1705 if (!http_find_header(htx, hdr, &ctx, 0))
1706 break;
Willy Tarreau79e57332018-10-02 16:01:16 +02001707
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001708 if (ctx.value.len < cook_l + 1)
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001709 continue;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001710
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001711 val_beg = ctx.value.ptr;
1712 val_end = val_beg + ctx.value.len;
Willy Tarreau79e57332018-10-02 16:01:16 +02001713 }
1714
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001715 smp->data.type = SMP_T_STR;
1716 smp->flags |= SMP_F_CONST;
1717 while ((val_beg = http_extract_cookie_value(val_beg, val_end,
Christopher Faulet97fc8da2020-11-13 13:41:04 +01001718 cook, cook_l,
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001719 (smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ,
1720 &smp->data.u.str.area,
1721 &smp->data.u.str.data))) {
1722 cnt++;
Willy Tarreau79e57332018-10-02 16:01:16 +02001723 }
1724 }
1725
1726 smp->data.type = SMP_T_SINT;
1727 smp->data.u.sint = cnt;
1728 smp->flags |= SMP_F_VOL_HDR;
1729 return 1;
1730}
1731
1732/* Fetch an cookie's integer value. The integer value is returned. It
1733 * takes a mandatory argument of type string. It relies on smp_fetch_cookie().
1734 */
1735static int smp_fetch_cookie_val(const struct arg *args, struct sample *smp, const char *kw, void *private)
1736{
1737 int ret = smp_fetch_cookie(args, smp, kw, private);
1738
1739 if (ret > 0) {
1740 smp->data.type = SMP_T_SINT;
1741 smp->data.u.sint = strl2ic(smp->data.u.str.area,
1742 smp->data.u.str.data);
1743 }
1744
1745 return ret;
1746}
1747
1748/************************************************************************/
1749/* The code below is dedicated to sample fetches */
1750/************************************************************************/
1751
1752/* This scans a URL-encoded query string. It takes an optionally wrapping
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001753 * string whose first contiguous chunk has its beginning in ctx->a[0] and end
Willy Tarreau79e57332018-10-02 16:01:16 +02001754 * in ctx->a[1], and the optional second part in (ctx->a[2]..ctx->a[3]). The
1755 * pointers are updated for next iteration before leaving.
1756 */
1757static int smp_fetch_param(char delim, const char *name, int name_len, const struct arg *args, struct sample *smp, const char *kw, void *private)
1758{
1759 const char *vstart, *vend;
1760 struct buffer *temp;
1761 const char **chunks = (const char **)smp->ctx.a;
1762
1763 if (!http_find_next_url_param(chunks, name, name_len,
1764 &vstart, &vend, delim))
1765 return 0;
1766
1767 /* Create sample. If the value is contiguous, return the pointer as CONST,
1768 * if the value is wrapped, copy-it in a buffer.
1769 */
1770 smp->data.type = SMP_T_STR;
1771 if (chunks[2] &&
1772 vstart >= chunks[0] && vstart <= chunks[1] &&
1773 vend >= chunks[2] && vend <= chunks[3]) {
1774 /* Wrapped case. */
1775 temp = get_trash_chunk();
1776 memcpy(temp->area, vstart, chunks[1] - vstart);
1777 memcpy(temp->area + ( chunks[1] - vstart ), chunks[2],
1778 vend - chunks[2]);
1779 smp->data.u.str.area = temp->area;
1780 smp->data.u.str.data = ( chunks[1] - vstart ) + ( vend - chunks[2] );
1781 } else {
1782 /* Contiguous case. */
1783 smp->data.u.str.area = (char *)vstart;
1784 smp->data.u.str.data = vend - vstart;
1785 smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
1786 }
1787
1788 /* Update context, check wrapping. */
1789 chunks[0] = vend;
1790 if (chunks[2] && vend >= chunks[2] && vend <= chunks[3]) {
1791 chunks[1] = chunks[3];
1792 chunks[2] = NULL;
1793 }
1794
1795 if (chunks[0] < chunks[1])
1796 smp->flags |= SMP_F_NOT_LAST;
1797
1798 return 1;
1799}
1800
1801/* This function iterates over each parameter of the query string. It uses
1802 * ctx->a[0] and ctx->a[1] to store the beginning and end of the current
1803 * parameter. Since it uses smp_fetch_param(), ctx->a[2..3] are both NULL.
1804 * An optional parameter name is passed in args[0], otherwise any parameter is
1805 * considered. It supports an optional delimiter argument for the beginning of
1806 * the string in args[1], which defaults to "?".
1807 */
1808static int smp_fetch_url_param(const struct arg *args, struct sample *smp, const char *kw, void *private)
1809{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001810 struct channel *chn = SMP_REQ_CHN(smp);
Willy Tarreau79e57332018-10-02 16:01:16 +02001811 char delim = '?';
1812 const char *name;
1813 int name_len;
1814
1815 if (!args ||
1816 (args[0].type && args[0].type != ARGT_STR) ||
1817 (args[1].type && args[1].type != ARGT_STR))
1818 return 0;
1819
1820 name = "";
1821 name_len = 0;
1822 if (args->type == ARGT_STR) {
1823 name = args->data.str.area;
1824 name_len = args->data.str.data;
1825 }
1826
1827 if (args[1].type)
1828 delim = *args[1].data.str.area;
1829
1830 if (!smp->ctx.a[0]) { // first call, find the query string
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001831 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001832 struct htx_sl *sl;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001833
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001834 if (!htx)
1835 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001836
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001837 sl = http_get_stline(htx);
1838 smp->ctx.a[0] = http_find_param_list(HTX_SL_REQ_UPTR(sl), HTX_SL_REQ_ULEN(sl), delim);
1839 if (!smp->ctx.a[0])
1840 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001841
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001842 smp->ctx.a[1] = HTX_SL_REQ_UPTR(sl) + HTX_SL_REQ_ULEN(sl);
Willy Tarreau79e57332018-10-02 16:01:16 +02001843
1844 /* Assume that the context is filled with NULL pointer
1845 * before the first call.
1846 * smp->ctx.a[2] = NULL;
1847 * smp->ctx.a[3] = NULL;
1848 */
1849 }
1850
1851 return smp_fetch_param(delim, name, name_len, args, smp, kw, private);
1852}
1853
1854/* This function iterates over each parameter of the body. This requires
1855 * that the body has been waited for using http-buffer-request. It uses
1856 * ctx->a[0] and ctx->a[1] to store the beginning and end of the first
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001857 * contiguous part of the body, and optionally ctx->a[2..3] to reference the
Willy Tarreau79e57332018-10-02 16:01:16 +02001858 * optional second part if the body wraps at the end of the buffer. An optional
1859 * parameter name is passed in args[0], otherwise any parameter is considered.
1860 */
1861static int smp_fetch_body_param(const struct arg *args, struct sample *smp, const char *kw, void *private)
1862{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001863 struct channel *chn = SMP_REQ_CHN(smp);
Willy Tarreau79e57332018-10-02 16:01:16 +02001864 const char *name;
1865 int name_len;
1866
1867 if (!args || (args[0].type && args[0].type != ARGT_STR))
1868 return 0;
1869
1870 name = "";
1871 name_len = 0;
1872 if (args[0].type == ARGT_STR) {
1873 name = args[0].data.str.area;
1874 name_len = args[0].data.str.data;
1875 }
1876
1877 if (!smp->ctx.a[0]) { // first call, find the query string
Christopher Faulete596d182020-05-05 17:46:34 +02001878 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001879 struct buffer *temp;
1880 int32_t pos;
Willy Tarreau79e57332018-10-02 16:01:16 +02001881
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001882 if (!htx)
1883 return 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001884
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001885 temp = get_trash_chunk();
1886 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
1887 struct htx_blk *blk = htx_get_blk(htx, pos);
1888 enum htx_blk_type type = htx_get_blk_type(blk);
Willy Tarreau79e57332018-10-02 16:01:16 +02001889
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001890 if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT)
1891 break;
1892 if (type == HTX_BLK_DATA) {
Christopher Faulet53a899b2019-10-08 16:38:42 +02001893 if (!h1_format_htx_data(htx_get_blk_value(htx, blk), temp, 0))
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001894 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001895 }
Willy Tarreau79e57332018-10-02 16:01:16 +02001896 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001897
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001898 smp->ctx.a[0] = temp->area;
1899 smp->ctx.a[1] = temp->area + temp->data;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001900
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001901 /* Assume that the context is filled with NULL pointer
1902 * before the first call.
1903 * smp->ctx.a[2] = NULL;
1904 * smp->ctx.a[3] = NULL;
1905 */
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001906
Willy Tarreau79e57332018-10-02 16:01:16 +02001907 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001908
Willy Tarreau79e57332018-10-02 16:01:16 +02001909 return smp_fetch_param('&', name, name_len, args, smp, kw, private);
1910}
1911
1912/* Return the signed integer value for the specified url parameter (see url_param
1913 * above).
1914 */
1915static int smp_fetch_url_param_val(const struct arg *args, struct sample *smp, const char *kw, void *private)
1916{
1917 int ret = smp_fetch_url_param(args, smp, kw, private);
1918
1919 if (ret > 0) {
1920 smp->data.type = SMP_T_SINT;
1921 smp->data.u.sint = strl2ic(smp->data.u.str.area,
1922 smp->data.u.str.data);
1923 }
1924
1925 return ret;
1926}
1927
1928/* This produces a 32-bit hash of the concatenation of the first occurrence of
1929 * the Host header followed by the path component if it begins with a slash ('/').
1930 * This means that '*' will not be added, resulting in exactly the first Host
1931 * entry. If no Host header is found, then the path is used. The resulting value
1932 * is hashed using the url hash followed by a full avalanche hash and provides a
1933 * 32-bit integer value. This fetch is useful for tracking per-URL activity on
1934 * high-traffic sites without having to store whole paths.
1935 * this differs from the base32 functions in that it includes the url parameters
1936 * as well as the path
1937 */
1938static int smp_fetch_url32(const struct arg *args, struct sample *smp, const char *kw, void *private)
1939{
Christopher Faulet89dc4992019-04-17 12:02:59 +02001940 struct channel *chn = SMP_REQ_CHN(smp);
Christopher Faulet778f5ed2020-04-29 15:51:55 +02001941 struct htx *htx = smp_prefetch_htx(smp, chn, NULL, 1);
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001942 struct http_hdr_ctx ctx;
1943 struct htx_sl *sl;
1944 struct ist path;
Willy Tarreau79e57332018-10-02 16:01:16 +02001945 unsigned int hash = 0;
Willy Tarreau79e57332018-10-02 16:01:16 +02001946
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001947 if (!htx)
1948 return 0;
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001949
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001950 ctx.blk = NULL;
1951 if (http_find_header(htx, ist("Host"), &ctx, 1)) {
1952 /* OK we have the header value in ctx.value */
1953 while (ctx.value.len--)
1954 hash = *(ctx.value.ptr++) + (hash << 6) + (hash << 16) - hash;
Willy Tarreau79e57332018-10-02 16:01:16 +02001955 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001956
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001957 /* now retrieve the path */
1958 sl = http_get_stline(htx);
1959 path = http_get_path(htx_sl_req_uri(sl));
Christopher Faulet6d1dd462019-07-15 14:36:03 +02001960 if (path.len && *(path.ptr) == '/') {
1961 while (path.len--)
1962 hash = *(path.ptr++) + (hash << 6) + (hash << 16) - hash;
Willy Tarreau79e57332018-10-02 16:01:16 +02001963 }
Christopher Faulet311c7ea2018-10-24 21:41:55 +02001964
Willy Tarreau79e57332018-10-02 16:01:16 +02001965 hash = full_hash(hash);
1966
1967 smp->data.type = SMP_T_SINT;
1968 smp->data.u.sint = hash;
1969 smp->flags = SMP_F_VOL_1ST;
1970 return 1;
1971}
1972
1973/* This concatenates the source address with the 32-bit hash of the Host and
1974 * URL as returned by smp_fetch_base32(). The idea is to have per-source and
1975 * per-url counters. The result is a binary block from 8 to 20 bytes depending
1976 * on the source address length. The URL hash is stored before the address so
1977 * that in environments where IPv6 is insignificant, truncating the output to
1978 * 8 bytes would still work.
1979 */
1980static int smp_fetch_url32_src(const struct arg *args, struct sample *smp, const char *kw, void *private)
1981{
1982 struct buffer *temp;
1983 struct connection *cli_conn = objt_conn(smp->sess->origin);
1984
Willy Tarreaucd7ca792019-07-17 16:57:03 +02001985 if (!cli_conn || !conn_get_src(cli_conn))
Willy Tarreau79e57332018-10-02 16:01:16 +02001986 return 0;
1987
1988 if (!smp_fetch_url32(args, smp, kw, private))
1989 return 0;
1990
1991 temp = get_trash_chunk();
1992 *(unsigned int *) temp->area = htonl(smp->data.u.sint);
1993 temp->data += sizeof(unsigned int);
1994
Willy Tarreau9a1efe12019-07-17 17:13:50 +02001995 switch (cli_conn->src->ss_family) {
Willy Tarreau79e57332018-10-02 16:01:16 +02001996 case AF_INET:
1997 memcpy(temp->area + temp->data,
Willy Tarreau9a1efe12019-07-17 17:13:50 +02001998 &((struct sockaddr_in *)cli_conn->src)->sin_addr,
Willy Tarreau79e57332018-10-02 16:01:16 +02001999 4);
2000 temp->data += 4;
2001 break;
2002 case AF_INET6:
2003 memcpy(temp->area + temp->data,
Willy Tarreau9a1efe12019-07-17 17:13:50 +02002004 &((struct sockaddr_in6 *)cli_conn->src)->sin6_addr,
Willy Tarreau79e57332018-10-02 16:01:16 +02002005 16);
2006 temp->data += 16;
2007 break;
2008 default:
2009 return 0;
2010 }
2011
2012 smp->data.u.str = *temp;
2013 smp->data.type = SMP_T_BIN;
2014 return 1;
2015}
2016
2017/************************************************************************/
2018/* Other utility functions */
2019/************************************************************************/
2020
2021/* This function is used to validate the arguments passed to any "hdr" fetch
2022 * keyword. These keywords support an optional positive or negative occurrence
2023 * number. We must ensure that the number is greater than -MAX_HDR_HISTORY. It
2024 * is assumed that the types are already the correct ones. Returns 0 on error,
2025 * non-zero if OK. If <err> is not NULL, it will be filled with a pointer to an
2026 * error message in case of error, that the caller is responsible for freeing.
2027 * The initial location must either be freeable or NULL.
2028 * Note: this function's pointer is checked from Lua.
2029 */
2030int val_hdr(struct arg *arg, char **err_msg)
2031{
2032 if (arg && arg[1].type == ARGT_SINT && arg[1].data.sint < -MAX_HDR_HISTORY) {
2033 memprintf(err_msg, "header occurrence must be >= %d", -MAX_HDR_HISTORY);
2034 return 0;
2035 }
2036 return 1;
2037}
2038
2039/************************************************************************/
2040/* All supported sample fetch keywords must be declared here. */
2041/************************************************************************/
2042
2043/* Note: must not be declared <const> as its list will be overwritten */
2044static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
2045 { "base", smp_fetch_base, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2046 { "base32", smp_fetch_base32, 0, NULL, SMP_T_SINT, SMP_USE_HRQHV },
2047 { "base32+src", smp_fetch_base32_src, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV },
2048
2049 /* capture are allocated and are permanent in the stream */
2050 { "capture.req.hdr", smp_fetch_capture_req_hdr, ARG1(1,SINT), NULL, SMP_T_STR, SMP_USE_HRQHP },
2051
2052 /* retrieve these captures from the HTTP logs */
2053 { "capture.req.method", smp_fetch_capture_req_method, 0, NULL, SMP_T_STR, SMP_USE_HRQHP },
2054 { "capture.req.uri", smp_fetch_capture_req_uri, 0, NULL, SMP_T_STR, SMP_USE_HRQHP },
2055 { "capture.req.ver", smp_fetch_capture_req_ver, 0, NULL, SMP_T_STR, SMP_USE_HRQHP },
2056
2057 { "capture.res.hdr", smp_fetch_capture_res_hdr, ARG1(1,SINT), NULL, SMP_T_STR, SMP_USE_HRSHP },
2058 { "capture.res.ver", smp_fetch_capture_res_ver, 0, NULL, SMP_T_STR, SMP_USE_HRQHP },
2059
2060 /* cookie is valid in both directions (eg: for "stick ...") but cook*
2061 * are only here to match the ACL's name, are request-only and are used
2062 * for ACL compatibility only.
2063 */
2064 { "cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV },
Christopher Fauletc1f40dd2019-05-16 10:07:30 +02002065 { "cookie", smp_fetch_chn_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV|SMP_USE_HRSHV },
Willy Tarreau79e57332018-10-02 16:01:16 +02002066 { "cook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2067 { "cook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2068
2069 /* hdr is valid in both directions (eg: for "stick ...") but hdr_* are
2070 * only here to match the ACL's name, are request-only and are used for
2071 * ACL compatibility only.
2072 */
Christopher Fauletc1f40dd2019-05-16 10:07:30 +02002073 { "hdr", smp_fetch_chn_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRQHV|SMP_USE_HRSHV },
Willy Tarreau79e57332018-10-02 16:01:16 +02002074 { "hdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2075 { "hdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRQHV },
2076 { "hdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_SINT, SMP_USE_HRQHV },
2077
Christopher Fauleta4063562019-08-02 11:51:37 +02002078 { "http_auth_type", smp_fetch_http_auth_type, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2079 { "http_auth_user", smp_fetch_http_auth_user, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2080 { "http_auth_pass", smp_fetch_http_auth_pass, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
Willy Tarreau79e57332018-10-02 16:01:16 +02002081 { "http_auth", smp_fetch_http_auth, ARG1(1,USR), NULL, SMP_T_BOOL, SMP_USE_HRQHV },
2082 { "http_auth_group", smp_fetch_http_auth_grp, ARG1(1,USR), NULL, SMP_T_STR, SMP_USE_HRQHV },
2083 { "http_first_req", smp_fetch_http_first_req, 0, NULL, SMP_T_BOOL, SMP_USE_HRQHP },
2084 { "method", smp_fetch_meth, 0, NULL, SMP_T_METH, SMP_USE_HRQHP },
2085 { "path", smp_fetch_path, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
Christopher Faulete720c322020-09-02 17:25:18 +02002086 { "pathq", smp_fetch_path, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
Willy Tarreau79e57332018-10-02 16:01:16 +02002087 { "query", smp_fetch_query, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2088
2089 /* HTTP protocol on the request path */
2090 { "req.proto_http", smp_fetch_proto_http, 0, NULL, SMP_T_BOOL, SMP_USE_HRQHP },
2091 { "req_proto_http", smp_fetch_proto_http, 0, NULL, SMP_T_BOOL, SMP_USE_HRQHP },
2092
2093 /* HTTP version on the request path */
2094 { "req.ver", smp_fetch_rqver, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2095 { "req_ver", smp_fetch_rqver, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2096
2097 { "req.body", smp_fetch_body, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV },
2098 { "req.body_len", smp_fetch_body_len, 0, NULL, SMP_T_SINT, SMP_USE_HRQHV },
2099 { "req.body_size", smp_fetch_body_size, 0, NULL, SMP_T_SINT, SMP_USE_HRQHV },
2100 { "req.body_param", smp_fetch_body_param, ARG1(0,STR), NULL, SMP_T_BIN, SMP_USE_HRQHV },
2101
2102 { "req.hdrs", smp_fetch_hdrs, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV },
2103 { "req.hdrs_bin", smp_fetch_hdrs_bin, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV },
2104
2105 /* HTTP version on the response path */
2106 { "res.ver", smp_fetch_stver, 0, NULL, SMP_T_STR, SMP_USE_HRSHV },
2107 { "resp_ver", smp_fetch_stver, 0, NULL, SMP_T_STR, SMP_USE_HRSHV },
2108
Christopher Faulete596d182020-05-05 17:46:34 +02002109 { "res.body", smp_fetch_body, 0, NULL, SMP_T_BIN, SMP_USE_HRSHV },
2110 { "res.body_len", smp_fetch_body_len, 0, NULL, SMP_T_SINT, SMP_USE_HRSHV },
2111 { "res.body_size", smp_fetch_body_size, 0, NULL, SMP_T_SINT, SMP_USE_HRSHV },
2112
2113 { "res.hdrs", smp_fetch_hdrs, 0, NULL, SMP_T_BIN, SMP_USE_HRSHV },
2114 { "res.hdrs_bin", smp_fetch_hdrs_bin, 0, NULL, SMP_T_BIN, SMP_USE_HRSHV },
2115
Willy Tarreau79e57332018-10-02 16:01:16 +02002116 /* explicit req.{cook,hdr} are used to force the fetch direction to be request-only */
2117 { "req.cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV },
2118 { "req.cook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2119 { "req.cook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2120
2121 { "req.fhdr", smp_fetch_fhdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRQHV },
2122 { "req.fhdr_cnt", smp_fetch_fhdr_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2123 { "req.hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRQHV },
2124 { "req.hdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
2125 { "req.hdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRQHV },
2126 { "req.hdr_names", smp_fetch_hdr_names, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV },
2127 { "req.hdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_SINT, SMP_USE_HRQHV },
2128
2129 /* explicit req.{cook,hdr} are used to force the fetch direction to be response-only */
2130 { "res.cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV },
2131 { "res.cook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2132 { "res.cook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2133
2134 { "res.fhdr", smp_fetch_fhdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRSHV },
2135 { "res.fhdr_cnt", smp_fetch_fhdr_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2136 { "res.hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRSHV },
2137 { "res.hdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2138 { "res.hdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRSHV },
2139 { "res.hdr_names", smp_fetch_hdr_names, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV },
2140 { "res.hdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_SINT, SMP_USE_HRSHV },
2141
2142 /* scook is valid only on the response and is used for ACL compatibility */
2143 { "scook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV },
2144 { "scook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2145 { "scook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2146 { "set-cookie", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV }, /* deprecated */
2147
2148 /* shdr is valid only on the response and is used for ACL compatibility */
2149 { "shdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRSHV },
2150 { "shdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_SINT, SMP_USE_HRSHV },
2151 { "shdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRSHV },
2152 { "shdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_SINT, SMP_USE_HRSHV },
2153
2154 { "status", smp_fetch_stcode, 0, NULL, SMP_T_SINT, SMP_USE_HRSHP },
2155 { "unique-id", smp_fetch_uniqueid, 0, NULL, SMP_T_STR, SMP_SRC_L4SRV },
2156 { "url", smp_fetch_url, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
2157 { "url32", smp_fetch_url32, 0, NULL, SMP_T_SINT, SMP_USE_HRQHV },
2158 { "url32+src", smp_fetch_url32_src, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV },
2159 { "url_ip", smp_fetch_url_ip, 0, NULL, SMP_T_IPV4, SMP_USE_HRQHV },
2160 { "url_port", smp_fetch_url_port, 0, NULL, SMP_T_SINT, SMP_USE_HRQHV },
2161 { "url_param", smp_fetch_url_param, ARG2(0,STR,STR), NULL, SMP_T_STR, SMP_USE_HRQHV },
2162 { "urlp" , smp_fetch_url_param, ARG2(0,STR,STR), NULL, SMP_T_STR, SMP_USE_HRQHV },
2163 { "urlp_val", smp_fetch_url_param_val, ARG2(0,STR,STR), NULL, SMP_T_SINT, SMP_USE_HRQHV },
Christopher Faulet16032ab2020-04-30 11:30:00 +02002164
Willy Tarreau79e57332018-10-02 16:01:16 +02002165 { /* END */ },
2166}};
2167
Willy Tarreau0108d902018-11-25 19:14:37 +01002168INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);
Willy Tarreau79e57332018-10-02 16:01:16 +02002169
2170/*
2171 * Local variables:
2172 * c-indent-level: 8
2173 * c-basic-offset: 8
2174 * End:
2175 */