blob: 3a0f3fbbcff2555f49a61057269ac6c183171da8 [file] [log] [blame]
Emeric Brun107ca302010-01-04 16:16:05 +01001/*
Willy Tarreaucd3b0942012-04-27 21:52:18 +02002 * Sample management functions.
Emeric Brun107ca302010-01-04 16:16:05 +01003 *
4 * Copyright 2009-2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
Willy Tarreaucd3b0942012-04-27 21:52:18 +02005 * Copyright (C) 2012 Willy Tarreau <w@1wt.eu>
Emeric Brun107ca302010-01-04 16:16:05 +01006 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
14#include <string.h>
15#include <arpa/inet.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020016#include <stdio.h>
Emeric Brun107ca302010-01-04 16:16:05 +010017
Willy Tarreau7e2c6472012-10-29 20:44:36 +010018#include <types/global.h>
19
Willy Tarreauc7e42382012-08-24 19:22:53 +020020#include <common/chunk.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020021#include <common/standard.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020022#include <common/uri_auth.h>
Emeric Brun53d1a982014-04-30 18:21:37 +020023#include <common/base64.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020024
Willy Tarreau9fcb9842012-04-20 14:45:49 +020025#include <proto/arg.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020026#include <proto/auth.h>
27#include <proto/log.h>
Thierry FOURNIERd4373142013-12-17 01:10:10 +010028#include <proto/proto_http.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020029#include <proto/proxy.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020030#include <proto/sample.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020031#include <proto/stick_table.h>
Emeric Brun107ca302010-01-04 16:16:05 +010032
Willy Tarreau1cf8f082014-02-07 12:14:54 +010033/* sample type names */
34const char *smp_to_type[SMP_TYPES] = {
35 [SMP_T_BOOL] = "bool",
36 [SMP_T_UINT] = "uint",
37 [SMP_T_SINT] = "sint",
38 [SMP_T_ADDR] = "addr",
39 [SMP_T_IPV4] = "ipv4",
40 [SMP_T_IPV6] = "ipv6",
41 [SMP_T_STR] = "str",
42 [SMP_T_BIN] = "bin",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010043};
44
Willy Tarreau12785782012-04-27 21:37:17 +020045/* static sample used in sample_process() when <p> is NULL */
Willy Tarreaub4a88f02012-04-23 21:35:11 +020046static struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010047
Willy Tarreau12785782012-04-27 21:37:17 +020048/* list head of all known sample fetch keywords */
49static struct sample_fetch_kw_list sample_fetches = {
50 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010051};
52
Willy Tarreau12785782012-04-27 21:37:17 +020053/* list head of all known sample format conversion keywords */
54static struct sample_conv_kw_list sample_convs = {
55 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010056};
57
Willy Tarreau80aca902013-01-07 15:42:20 +010058const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
59 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
60 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
61 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
62 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
63 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
64 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
65 SMP_VAL_FE_LOG_END),
66
67 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
68 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
69 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
70 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
71 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
72 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
73 SMP_VAL_FE_LOG_END),
74
75 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
76 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
77 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
78 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
79 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
80 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
81 SMP_VAL_FE_LOG_END),
82
83 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
84 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
85 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
86 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
87 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
88 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
89 SMP_VAL_FE_LOG_END),
90
91 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
92 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
93 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
94 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
95 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
96 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
97 SMP_VAL_FE_LOG_END),
98
99 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
100 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
101 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
102 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
103 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
104 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
105 SMP_VAL_FE_LOG_END),
106
107 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
108 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
109 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
110 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
111 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
112 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
113 SMP_VAL___________),
114
115 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
116 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
117 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
118 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
119 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
120 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
121 SMP_VAL___________),
122
123 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
124 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
125 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
126 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
127 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
128 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
129 SMP_VAL_FE_LOG_END),
130
131 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
132 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
133 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
134 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
135 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
136 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
137 SMP_VAL___________),
138
139 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
140 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
141 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
142 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
143 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
144 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
145 SMP_VAL_FE_LOG_END),
146
147 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
148 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
149 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
150 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
151 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
152 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
153 SMP_VAL_FE_LOG_END),
154
155 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
156 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
157 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
158 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
159 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
160 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
161 SMP_VAL_FE_LOG_END),
162
163 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
164 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
165 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
166 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
167 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
168 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
169 SMP_VAL_FE_LOG_END),
170
171 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
172 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
173 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
174 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
175 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
176 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
177 SMP_VAL___________),
178
179 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
180 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
181 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
182 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
183 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
184 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
185 SMP_VAL___________),
186
187 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
188 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
189 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
190 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
191 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
192 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
193 SMP_VAL_FE_LOG_END),
194
195 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
196 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
197 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
198 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
199 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
200 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
201 SMP_VAL___________),
202
203 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
204 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
205 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
206 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
207 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
208 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
209 SMP_VAL_FE_LOG_END),
210
211 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
212 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
213 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
214 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
215 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
216 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
217 SMP_VAL_FE_LOG_END),
218
219 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
220 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
221 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
222 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
223 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
224 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
225 SMP_VAL_FE_LOG_END),
226
227 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
228 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
229 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
230 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
231 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
232 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
233 SMP_VAL_FE_LOG_END),
234};
235
236static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
237 [SMP_SRC_INTRN] = "internal state",
238 [SMP_SRC_LISTN] = "listener",
239 [SMP_SRC_FTEND] = "frontend",
240 [SMP_SRC_L4CLI] = "client address",
241 [SMP_SRC_L5CLI] = "client-side connection",
242 [SMP_SRC_TRACK] = "track counters",
243 [SMP_SRC_L6REQ] = "request buffer",
244 [SMP_SRC_HRQHV] = "HTTP request headers",
245 [SMP_SRC_HRQHP] = "HTTP request",
246 [SMP_SRC_HRQBO] = "HTTP request body",
247 [SMP_SRC_BKEND] = "backend",
248 [SMP_SRC_SERVR] = "server",
249 [SMP_SRC_L4SRV] = "server address",
250 [SMP_SRC_L5SRV] = "server-side connection",
251 [SMP_SRC_L6RES] = "response buffer",
252 [SMP_SRC_HRSHV] = "HTTP response headers",
253 [SMP_SRC_HRSHP] = "HTTP response",
254 [SMP_SRC_HRSBO] = "HTTP response body",
255 [SMP_SRC_RQFIN] = "request buffer statistics",
256 [SMP_SRC_RSFIN] = "response buffer statistics",
257 [SMP_SRC_TXFIN] = "transaction statistics",
258 [SMP_SRC_SSFIN] = "session statistics",
259};
260
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100261static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
262 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
263 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
264 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
265 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
266 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
267 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
268 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
269 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
270 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
271 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
272 [SMP_CKP_BE_SRV_CON] = "server source selection",
273 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
274 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
275 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
276 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
277 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
278 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
279 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
280 [SMP_CKP_FE_LOG_END] = "logs",
281};
282
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100283/* This function returns the type of the data returned by the sample_expr.
284 * It assumes that the <expr> and all of its converters are properly
285 * initialized.
286 */
287inline
288int smp_expr_output_type(struct sample_expr *expr)
289{
290 struct sample_conv_expr *smp_expr;
291
292 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
293 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
294 return smp_expr->conv->out_type;
295 }
296 return expr->fetch->out_type;
297}
298
299
Willy Tarreau80aca902013-01-07 15:42:20 +0100300/* fill the trash with a comma-delimited list of source names for the <use> bit
301 * field which must be composed of a non-null set of SMP_USE_* flags. The return
302 * value is the pointer to the string in the trash buffer.
303 */
304const char *sample_src_names(unsigned int use)
305{
306 int bit;
307
308 trash.len = 0;
309 trash.str[0] = '\0';
310 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
311 if (!(use & ~((1 << bit) - 1)))
312 break; /* no more bits */
313
314 if (!(use & (1 << bit)))
315 continue; /* bit not set */
316
317 trash.len += snprintf(trash.str + trash.len, trash.size - trash.len, "%s%s",
318 (use & ((1 << bit) - 1)) ? "," : "",
319 fetch_src_names[bit]);
320 }
321 return trash.str;
322}
323
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100324/* return a pointer to the correct sample checkpoint name, or "unknown" when
325 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
326 * if set.
327 */
328const char *sample_ckp_names(unsigned int use)
329{
330 int bit;
331
332 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
333 if (use & (1 << bit))
334 return fetch_ckp_names[bit];
335 return "unknown sample check place, please report this bug";
336}
337
Emeric Brun107ca302010-01-04 16:16:05 +0100338/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100339 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
340 * for next parsing sessions. The fetch keywords capabilities are also computed
341 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100342 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100343void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100344{
Willy Tarreau80aca902013-01-07 15:42:20 +0100345 struct sample_fetch *sf;
346 int bit;
347
348 for (sf = kwl->kw; sf->kw != NULL; sf++) {
349 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
350 if (sf->use & (1 << bit))
351 sf->val |= fetch_cap[bit];
352 }
353 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100354}
355
356/*
Willy Tarreau12785782012-04-27 21:37:17 +0200357 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100358 * parsing sessions.
359 */
Willy Tarreau12785782012-04-27 21:37:17 +0200360void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100361{
Willy Tarreau12785782012-04-27 21:37:17 +0200362 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100363}
364
365/*
Willy Tarreau12785782012-04-27 21:37:17 +0200366 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100367 * string of <len> in buffer <kw>.
368 *
369 */
Willy Tarreau12785782012-04-27 21:37:17 +0200370struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100371{
372 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200373 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100374
Willy Tarreau12785782012-04-27 21:37:17 +0200375 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100376 for (index = 0; kwl->kw[index].kw != NULL; index++) {
377 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
378 kwl->kw[index].kw[len] == '\0')
379 return &kwl->kw[index];
380 }
381 }
382 return NULL;
383}
384
385/*
Willy Tarreau12785782012-04-27 21:37:17 +0200386 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100387 * string of <len> in buffer <kw>.
388 *
389 */
Willy Tarreau12785782012-04-27 21:37:17 +0200390struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100391{
392 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200393 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100394
Willy Tarreau12785782012-04-27 21:37:17 +0200395 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100396 for (index = 0; kwl->kw[index].kw != NULL; index++) {
397 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
398 kwl->kw[index].kw[len] == '\0')
399 return &kwl->kw[index];
400 }
401 }
402 return NULL;
403}
404
Emeric Brun107ca302010-01-04 16:16:05 +0100405/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200406/* Sample casts functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200407/* Note: these functions do *NOT* set the output type on the */
408/* sample, the caller is responsible for doing this on return. */
Emeric Brun107ca302010-01-04 16:16:05 +0100409/******************************************************************/
410
Willy Tarreau342acb42012-04-23 22:03:39 +0200411static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100412{
Willy Tarreau342acb42012-04-23 22:03:39 +0200413 smp->data.uint = ntohl(smp->data.ipv4.s_addr);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100414 smp->type = SMP_T_UINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100415 return 1;
416}
417
Willy Tarreau342acb42012-04-23 22:03:39 +0200418static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100419{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100420 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100421
Willy Tarreau342acb42012-04-23 22:03:39 +0200422 if (!inet_ntop(AF_INET, (void *)&smp->data.ipv4, trash->str, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100423 return 0;
424
425 trash->len = strlen(trash->str);
Willy Tarreau342acb42012-04-23 22:03:39 +0200426 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100427 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100428 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100429
430 return 1;
431}
432
Willy Tarreau342acb42012-04-23 22:03:39 +0200433static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100434{
Willy Tarreau342acb42012-04-23 22:03:39 +0200435 v4tov6(&smp->data.ipv6, &smp->data.ipv4);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100436 smp->type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100437 return 1;
438}
439
Willy Tarreau342acb42012-04-23 22:03:39 +0200440static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100441{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100442 struct chunk *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100443
Willy Tarreau342acb42012-04-23 22:03:39 +0200444 if (!inet_ntop(AF_INET6, (void *)&smp->data.ipv6, trash->str, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100445 return 0;
446
447 trash->len = strlen(trash->str);
Willy Tarreau342acb42012-04-23 22:03:39 +0200448 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100449 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100450 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100451 return 1;
452}
453
454/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200455static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100456{
Willy Tarreau342acb42012-04-23 22:03:39 +0200457 return v6tov4(&smp->data.ipv4, &smp->data.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100458}
459*/
460
Willy Tarreau342acb42012-04-23 22:03:39 +0200461static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100462{
Willy Tarreau342acb42012-04-23 22:03:39 +0200463 smp->data.ipv4.s_addr = htonl(smp->data.uint);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100464 smp->type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100465 return 1;
466}
467
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100468static int c_str2addr(struct sample *smp)
469{
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100470 if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) {
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100471 if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6))
472 return 0;
473 smp->type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100474 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100475 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100476 }
477 smp->type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100478 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100479 return 1;
480}
481
Willy Tarreau342acb42012-04-23 22:03:39 +0200482static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100483{
Willy Tarreau342acb42012-04-23 22:03:39 +0200484 if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100485 return 0;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100486 smp->type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100487 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100488 return 1;
489}
490
Willy Tarreau342acb42012-04-23 22:03:39 +0200491static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100492{
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100493 if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6))
494 return 0;
495 smp->type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100496 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100497 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100498}
499
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100500/* The sample is always copied into a new one so that smp->size is always
501 * valid. The NULL char always enforces the end of string if it is met.
502 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200503static int c_bin2str(struct sample *smp)
504{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100505 struct chunk *trash = get_trash_chunk();
Emeric Brun8ac33d92012-10-17 13:36:06 +0200506 unsigned char c;
507 int ptr = 0;
508
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100509 while (ptr < smp->data.str.len) {
510 c = smp->data.str.str[ptr];
511 if (!c)
512 break;
513 trash->str[ptr] = c;
514 ptr++;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200515 }
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100516 trash->len = ptr;
517 trash->str[ptr] = 0;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200518 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100519 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100520 smp->flags &= ~SMP_F_CONST;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200521 return 1;
522}
523
Willy Tarreau342acb42012-04-23 22:03:39 +0200524static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100525{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100526 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100527 char *pos;
528
Willy Tarreau342acb42012-04-23 22:03:39 +0200529 pos = ultoa_r(smp->data.uint, trash->str, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100530
531 if (!pos)
532 return 0;
533
Emeric Brun485479d2010-09-23 18:02:19 +0200534 trash->size = trash->size - (pos - trash->str);
Emeric Brun107ca302010-01-04 16:16:05 +0100535 trash->str = pos;
536 trash->len = strlen(pos);
Willy Tarreau342acb42012-04-23 22:03:39 +0200537 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100538 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100539 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100540 return 1;
541}
542
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100543/* This function duplicates data and removes the flag "const". */
544int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200545{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100546 struct chunk *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200547
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100548 /* If the const flag is not set, we don't need to duplicate the
549 * pattern as it can be modified in place.
550 */
551 if (!(smp->flags & SMP_F_CONST))
552 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100553
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100554 switch (smp->type) {
555 case SMP_T_BOOL:
556 case SMP_T_UINT:
557 case SMP_T_SINT:
558 case SMP_T_ADDR:
559 case SMP_T_IPV4:
560 case SMP_T_IPV6:
561 /* These type are not const. */
562 break;
563 case SMP_T_STR:
564 case SMP_T_BIN:
565 /* Duplicate data. */
566 trash = get_trash_chunk();
567 trash->len = smp->data.str.len < trash->size ? smp->data.str.len : trash->size;
568 memcpy(trash->str, smp->data.str.str, trash->len);
569 smp->data.str = *trash;
570 break;
571 default:
572 /* Other cases are unexpected. */
573 return 0;
574 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100575
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100576 /* remove const flag */
577 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200578 return 1;
579}
580
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100581int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100582{
583 return 1;
584}
585
Willy Tarreau342acb42012-04-23 22:03:39 +0200586static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100587{
588 int i;
589 uint32_t ret = 0;
590
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100591 if (smp->data.str.len == 0)
592 return 0;
593
Willy Tarreau342acb42012-04-23 22:03:39 +0200594 for (i = 0; i < smp->data.str.len; i++) {
595 uint32_t val = smp->data.str.str[i] - '0';
Emeric Brun107ca302010-01-04 16:16:05 +0100596
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100597 if (val > 9) {
598 if (i == 0)
599 return 0;
Emeric Brun107ca302010-01-04 16:16:05 +0100600 break;
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100601 }
Emeric Brun107ca302010-01-04 16:16:05 +0100602
603 ret = ret * 10 + val;
604 }
605
Willy Tarreau342acb42012-04-23 22:03:39 +0200606 smp->data.uint = ret;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100607 smp->type = SMP_T_UINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100608 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100609 return 1;
610}
611
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100612static int c_str2meth(struct sample *smp)
613{
614 enum http_meth_t meth;
615 int len;
616
617 meth = find_http_meth(smp->data.str.str, smp->data.str.len);
618 if (meth == HTTP_METH_OTHER) {
619 len = smp->data.str.len;
620 smp->data.meth.str.str = smp->data.str.str;
621 smp->data.meth.str.len = len;
622 }
623 else
624 smp->flags &= ~SMP_F_CONST;
625 smp->data.meth.meth = meth;
626 smp->type = SMP_T_METH;
627 return 1;
628}
629
630static int c_meth2str(struct sample *smp)
631{
632 int len;
633 enum http_meth_t meth;
634
635 if (smp->data.meth.meth == HTTP_METH_OTHER) {
636 /* The method is unknown. Copy the original pointer. */
637 len = smp->data.meth.str.len;
638 smp->data.str.str = smp->data.meth.str.str;
639 smp->data.str.len = len;
640 smp->type = SMP_T_STR;
641 }
642 else if (smp->data.meth.meth < HTTP_METH_OTHER) {
643 /* The method is known, copy the pointer containing the string. */
644 meth = smp->data.meth.meth;
645 smp->data.str.str = http_known_methods[meth].name;
646 smp->data.str.len = http_known_methods[meth].len;
647 smp->flags |= SMP_F_CONST;
648 smp->type = SMP_T_STR;
649 }
650 else {
651 /* Unknown method */
652 return 0;
653 }
654 return 1;
655}
656
Emeric Brun107ca302010-01-04 16:16:05 +0100657/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200658/* Sample casts matrix: */
659/* sample_casts[from type][to type] */
660/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100661/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100662
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100663sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100664/* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN METH */
665/* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
666/* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, NULL, },
667/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, NULL, },
668/* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
669/* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, NULL, NULL, },
670/* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, NULL, NULL, },
671/* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
672/* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
673/* METH */ { NULL, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, },
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200674};
Emeric Brun107ca302010-01-04 16:16:05 +0100675
Emeric Brun107ca302010-01-04 16:16:05 +0100676/*
Willy Tarreau12785782012-04-27 21:37:17 +0200677 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100678 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200679 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200680 * The caller must have set al->ctx.
Emeric Brun107ca302010-01-04 16:16:05 +0100681 */
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100682struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err_msg, struct arg_list *al)
Emeric Brun107ca302010-01-04 16:16:05 +0100683{
Willy Tarreau833cc792013-07-24 15:34:19 +0200684 const char *begw; /* beginning of word */
685 const char *endw; /* end of word */
686 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200687 struct sample_expr *expr;
688 struct sample_fetch *fetch;
689 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100690 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200691 char *fkw = NULL;
692 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100693 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100694
Willy Tarreau833cc792013-07-24 15:34:19 +0200695 begw = str[*idx];
696 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
697
698 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100699 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100700 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200701 }
Emeric Brun107ca302010-01-04 16:16:05 +0100702
Willy Tarreau833cc792013-07-24 15:34:19 +0200703 /* keep a copy of the current fetch keyword for error reporting */
704 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100705
Willy Tarreau833cc792013-07-24 15:34:19 +0200706 fetch = find_sample_fetch(begw, endw - begw);
707 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100708 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100709 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200710 }
Emeric Brun107ca302010-01-04 16:16:05 +0100711
Willy Tarreau833cc792013-07-24 15:34:19 +0200712 endt = endw;
713 if (*endt == '(') {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100714 /* look for the end of this term and skip the opening parenthesis */
715 endt = ++endw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200716 while (*endt && *endt != ')')
717 endt++;
718 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100719 memprintf(err_msg, "missing closing ')' after arguments to fetch keyword '%s'", fkw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200720 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200721 }
Emeric Brun485479d2010-09-23 18:02:19 +0200722 }
Emeric Brun107ca302010-01-04 16:16:05 +0100723
Willy Tarreau833cc792013-07-24 15:34:19 +0200724 /* At this point, we have :
725 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100726 * - endw : end of the keyword, first character not part of keyword
727 * nor the opening parenthesis (so first character of args
728 * if present).
Willy Tarreau833cc792013-07-24 15:34:19 +0200729 * - endt : end of the term (=endw or last parenthesis if args are present)
730 */
731
732 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100733 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100734 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200735 }
Emeric Brun107ca302010-01-04 16:16:05 +0100736 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200737
Willy Tarreau12785782012-04-27 21:37:17 +0200738 expr = calloc(1, sizeof(struct sample_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200739 if (!expr)
740 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100741
742 LIST_INIT(&(expr->conv_exprs));
743 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200744 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100745
Willy Tarreau689a1df2013-12-13 00:40:11 +0100746 /* Note that we call the argument parser even with an empty string,
747 * this allows it to automatically create entries for mandatory
748 * implicit arguments (eg: local proxy name).
749 */
750 al->kw = expr->fetch->kw;
751 al->conv = NULL;
752 if (make_arg_list(endw, endt - endw, fetch->arg_mask, &expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
753 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
754 goto out_error;
755 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200756
Willy Tarreau689a1df2013-12-13 00:40:11 +0100757 if (!expr->arg_p) {
758 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200759 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100760 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
761 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200762 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100763 }
764
Willy Tarreau833cc792013-07-24 15:34:19 +0200765 /* Now process the converters if any. We have two supported syntaxes
766 * for the converters, which can be combined :
767 * - comma-delimited list of converters just after the keyword and args ;
768 * - one converter per keyword
769 * The combination allows to have each keyword being a comma-delimited
770 * series of converters.
771 *
772 * We want to process the former first, then the latter. For this we start
773 * from the beginning of the supposed place in the exiting conv chain, which
774 * starts at the last comma (endt).
775 */
776
777 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200778 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100779
Willy Tarreau833cc792013-07-24 15:34:19 +0200780 if (*endt == ')') /* skip last closing parenthesis */
781 endt++;
Emeric Brun107ca302010-01-04 16:16:05 +0100782
Willy Tarreau833cc792013-07-24 15:34:19 +0200783 if (*endt && *endt != ',') {
784 if (ckw)
Willy Tarreau975c1782013-12-12 23:16:54 +0100785 memprintf(err_msg, "missing comma after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200786 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100787 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100788 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200789 }
Emeric Brun107ca302010-01-04 16:16:05 +0100790
Willy Tarreau833cc792013-07-24 15:34:19 +0200791 while (*endt == ',') /* then trailing commas */
792 endt++;
793
794 begw = endt; /* start of conv keyword */
795
796 if (!*begw) {
797 /* none ? skip to next string */
798 (*idx)++;
799 begw = str[*idx];
800 if (!begw || !*begw)
801 break;
802 }
803
804 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
805
806 free(ckw);
807 ckw = my_strndup(begw, endw - begw);
808
809 conv = find_sample_conv(begw, endw - begw);
810 if (!conv) {
811 /* we found an isolated keyword that we don't know, it's not ours */
812 if (begw == str[*idx])
813 break;
Willy Tarreau975c1782013-12-12 23:16:54 +0100814 memprintf(err_msg, "unknown conv method '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200815 goto out_error;
816 }
Emeric Brun107ca302010-01-04 16:16:05 +0100817
Willy Tarreau833cc792013-07-24 15:34:19 +0200818 endt = endw;
819 if (*endt == '(') {
820 /* look for the end of this term */
821 while (*endt && *endt != ')')
822 endt++;
823 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100824 memprintf(err_msg, "syntax error: missing ')' after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200825 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200826 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200827 }
828
829 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100830 memprintf(err_msg, "returns type of conv method '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100831 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200832 }
Emeric Brun107ca302010-01-04 16:16:05 +0100833
834 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200835 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100836 memprintf(err_msg, "conv method '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100837 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200838 }
Emeric Brun107ca302010-01-04 16:16:05 +0100839
840 prev_type = conv->out_type;
Willy Tarreau12785782012-04-27 21:37:17 +0200841 conv_expr = calloc(1, sizeof(struct sample_conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200842 if (!conv_expr)
843 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100844
845 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
846 conv_expr->conv = conv;
847
Willy Tarreau833cc792013-07-24 15:34:19 +0200848 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200849 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200850
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200851 if (!conv->arg_mask) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100852 memprintf(err_msg, "conv method '%s' does not support any args", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200853 goto out_error;
854 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100855
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200856 al->kw = expr->fetch->kw;
857 al->conv = conv_expr->conv->kw;
Willy Tarreau975c1782013-12-12 23:16:54 +0100858 if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
859 memprintf(err_msg, "invalid arg %d in conv method '%s' : %s", err_arg+1, ckw, *err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200860 goto out_error;
861 }
862
Willy Tarreau2e845be2012-10-19 19:49:09 +0200863 if (!conv_expr->arg_p)
864 conv_expr->arg_p = empty_arg_list;
865
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100866 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100867 memprintf(err_msg, "invalid args in conv method '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200868 goto out_error;
869 }
870 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200871 else if (ARGM(conv->arg_mask)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100872 memprintf(err_msg, "missing args for conv method '%s'", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200873 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100874 }
875 }
Emeric Brun485479d2010-09-23 18:02:19 +0200876
Willy Tarreau833cc792013-07-24 15:34:19 +0200877 out:
878 free(fkw);
879 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100880 return expr;
881
882out_error:
Willy Tarreau12785782012-04-27 21:37:17 +0200883 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +0200884 expr = NULL;
885 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +0100886}
887
888/*
Willy Tarreau12785782012-04-27 21:37:17 +0200889 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +0200890 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +0200891 * Returns a pointer on a typed sample structure containing the result or NULL if
892 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +0100893 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +0200894 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200895 *
896 * Note: the fetch functions are required to properly set the return type. The
897 * conversion functions must do so too. However the cast functions do not need
898 * to since they're made to cast mutiple types according to what is required.
Emeric Brun107ca302010-01-04 16:16:05 +0100899 */
Willy Tarreau12785782012-04-27 21:37:17 +0200900struct sample *sample_process(struct proxy *px, struct session *l4, void *l7,
901 unsigned int opt,
902 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +0100903{
Willy Tarreau12785782012-04-27 21:37:17 +0200904 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100905
Willy Tarreau18387e22013-07-25 12:02:38 +0200906 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +0200907 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +0200908 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +0200909 }
Emeric Brun107ca302010-01-04 16:16:05 +0100910
Willy Tarreauef38c392013-07-22 16:29:32 +0200911 if (!expr->fetch->process(px, l4, l7, opt, expr->arg_p, p, expr->fetch->kw))
Emeric Brun107ca302010-01-04 16:16:05 +0100912 return NULL;
913
Emeric Brun107ca302010-01-04 16:16:05 +0100914 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +0200915 /* we want to ensure that p->type can be casted into
916 * conv_expr->conv->in_type. We have 3 possibilities :
917 * - NULL => not castable.
918 * - c_none => nothing to do (let's optimize it)
919 * - other => apply cast and prepare to fail
920 */
Willy Tarreau12785782012-04-27 21:37:17 +0200921 if (!sample_casts[p->type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +0200922 return NULL;
923
Willy Tarreau12785782012-04-27 21:37:17 +0200924 if (sample_casts[p->type][conv_expr->conv->in_type] != c_none &&
925 !sample_casts[p->type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +0100926 return NULL;
927
Willy Tarreau12e50112012-04-25 17:21:49 +0200928 /* OK cast succeeded */
929
Willy Tarreau342acb42012-04-23 22:03:39 +0200930 if (!conv_expr->conv->process(conv_expr->arg_p, p))
Emeric Brun107ca302010-01-04 16:16:05 +0100931 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +0100932 }
933 return p;
934}
935
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +0100936/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200937 * Resolve all remaining arguments in proxy <p>. Returns the number of
938 * errors or 0 if everything is fine.
939 */
940int smp_resolve_args(struct proxy *p)
941{
942 struct arg_list *cur, *bak;
943 const char *ctx, *where;
944 const char *conv_ctx, *conv_pre, *conv_pos;
945 struct userlist *ul;
946 struct arg *arg;
947 int cfgerr = 0;
948
949 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
950 struct proxy *px;
951 struct server *srv;
952 char *pname, *sname;
953
954 arg = cur->arg;
955
956 /* prepare output messages */
957 conv_pre = conv_pos = conv_ctx = "";
958 if (cur->conv) {
959 conv_ctx = cur->conv;
960 conv_pre = "conversion keyword '";
961 conv_pos = "' for ";
962 }
963
964 where = "in";
965 ctx = "sample fetch keyword";
966 switch (cur->ctx) {
967 case ARGC_STK:where = "in stick rule in"; break;
968 case ARGC_TRK: where = "in tracking rule in"; break;
969 case ARGC_LOG: where = "in log-format string in"; break;
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100970 case ARGC_HRQ: where = "in http-request header format string in"; break;
971 case ARGC_HRS: where = "in http-response header format string in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200972 case ARGC_UIF: where = "in unique-id-format string in"; break;
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +0100973 case ARGC_RDR: where = "in redirect format string in"; break;
Willy Tarreau3a4ac422014-06-13 16:17:14 +0200974 case ARGC_CAP: where = "in capture rule in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200975 case ARGC_ACL: ctx = "ACL keyword"; break;
976 }
977
978 /* set a few default settings */
979 px = p;
980 pname = p->id;
981
982 switch (arg->type) {
983 case ARGT_SRV:
984 if (!arg->data.str.len) {
985 Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
986 cur->file, cur->line,
987 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
988 cfgerr++;
989 continue;
990 }
991
992 /* we support two formats : "bck/srv" and "srv" */
993 sname = strrchr(arg->data.str.str, '/');
994
995 if (sname) {
996 *sname++ = '\0';
997 pname = arg->data.str.str;
998
999 px = findproxy(pname, PR_CAP_BE);
1000 if (!px) {
1001 Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1002 cur->file, cur->line, pname,
1003 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1004 cfgerr++;
1005 break;
1006 }
1007 }
1008 else
1009 sname = arg->data.str.str;
1010
1011 srv = findserver(px, sname);
1012 if (!srv) {
1013 Alert("parsing [%s:%d] : unable to find server '%s' in proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1014 cur->file, cur->line, sname, pname,
1015 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1016 cfgerr++;
1017 break;
1018 }
1019
1020 free(arg->data.str.str);
1021 arg->data.str.str = NULL;
1022 arg->unresolved = 0;
1023 arg->data.srv = srv;
1024 break;
1025
1026 case ARGT_FE:
1027 if (arg->data.str.len) {
1028 pname = arg->data.str.str;
1029 px = findproxy(pname, PR_CAP_FE);
1030 }
1031
1032 if (!px) {
1033 Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1034 cur->file, cur->line, pname,
1035 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1036 cfgerr++;
1037 break;
1038 }
1039
1040 if (!(px->cap & PR_CAP_FE)) {
1041 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1042 cur->file, cur->line, pname,
1043 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1044 cfgerr++;
1045 break;
1046 }
1047
1048 free(arg->data.str.str);
1049 arg->data.str.str = NULL;
1050 arg->unresolved = 0;
1051 arg->data.prx = px;
1052 break;
1053
1054 case ARGT_BE:
1055 if (arg->data.str.len) {
1056 pname = arg->data.str.str;
1057 px = findproxy(pname, PR_CAP_BE);
1058 }
1059
1060 if (!px) {
1061 Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1062 cur->file, cur->line, pname,
1063 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1064 cfgerr++;
1065 break;
1066 }
1067
1068 if (!(px->cap & PR_CAP_BE)) {
1069 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1070 cur->file, cur->line, pname,
1071 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1072 cfgerr++;
1073 break;
1074 }
1075
1076 free(arg->data.str.str);
1077 arg->data.str.str = NULL;
1078 arg->unresolved = 0;
1079 arg->data.prx = px;
1080 break;
1081
1082 case ARGT_TAB:
1083 if (arg->data.str.len) {
1084 pname = arg->data.str.str;
1085 px = find_stktable(pname);
1086 }
1087
1088 if (!px) {
1089 Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1090 cur->file, cur->line, pname,
1091 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1092 cfgerr++;
1093 break;
1094 }
1095
1096 if (!px->table.size) {
1097 Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1098 cur->file, cur->line, pname,
1099 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1100 cfgerr++;
1101 break;
1102 }
1103
1104 free(arg->data.str.str);
1105 arg->data.str.str = NULL;
1106 arg->unresolved = 0;
1107 arg->data.prx = px;
1108 break;
1109
1110 case ARGT_USR:
1111 if (!arg->data.str.len) {
1112 Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1113 cur->file, cur->line,
1114 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1115 cfgerr++;
1116 break;
1117 }
1118
1119 if (p->uri_auth && p->uri_auth->userlist &&
1120 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1121 ul = p->uri_auth->userlist;
1122 else
1123 ul = auth_find_userlist(arg->data.str.str);
1124
1125 if (!ul) {
1126 Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1127 cur->file, cur->line, arg->data.str.str,
1128 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1129 cfgerr++;
1130 break;
1131 }
1132
1133 free(arg->data.str.str);
1134 arg->data.str.str = NULL;
1135 arg->unresolved = 0;
1136 arg->data.usr = ul;
1137 break;
1138 }
1139
1140 LIST_DEL(&cur->list);
1141 free(cur);
1142 } /* end of args processing */
1143
1144 return cfgerr;
1145}
1146
1147/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001148 * Process a fetch + format conversion as defined by the sample expression
1149 * <expr> on request or response considering the <opt> parameter. The output is
1150 * always of type string. If a stable sample can be fetched, or an unstable one
1151 * when <opt> contains SMP_OPT_FINAL, the sample is converted to a string and
1152 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1153 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1154 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1155 * take actions (eg: wait longer). If a sample could not be found or could not
1156 * be converted, NULL is returned.
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001157 */
1158struct sample *sample_fetch_string(struct proxy *px, struct session *l4, void *l7,
1159 unsigned int opt, struct sample_expr *expr)
1160{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001161 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001162
Willy Tarreau6c616e02014-06-25 16:56:41 +02001163 memset(smp, 0, sizeof(*smp));
1164
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001165 if (!sample_process(px, l4, l7, opt, expr, smp)) {
1166 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1167 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001168 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001169 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001170
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001171 if (!sample_casts[smp->type][SMP_T_STR])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001172 return NULL;
1173
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001174 if (!sample_casts[smp->type][SMP_T_STR](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001175 return NULL;
1176
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001177 smp->type = SMP_T_STR;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001178 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001179 return smp;
1180}
1181
Emeric Brun107ca302010-01-04 16:16:05 +01001182/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001183/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001184/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001185/*****************************************************************/
1186
Emeric Brun53d1a982014-04-30 18:21:37 +02001187static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp)
1188{
1189 struct chunk *trash = get_trash_chunk();
1190 int b64_len;
1191
1192 trash->len = 0;
1193 b64_len = a2base64(smp->data.str.str, smp->data.str.len, trash->str, trash->size);
1194 if (b64_len < 0)
1195 return 0;
1196
1197 trash->len = b64_len;
1198 smp->data.str = *trash;
1199 smp->type = SMP_T_STR;
1200 smp->flags &= ~SMP_F_CONST;
1201 return 1;
1202}
1203
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001204static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp)
1205{
1206 struct chunk *trash = get_trash_chunk();
1207 unsigned char c;
1208 int ptr = 0;
1209
1210 trash->len = 0;
1211 while (ptr < smp->data.str.len && trash->len <= trash->size - 2) {
1212 c = smp->data.str.str[ptr++];
1213 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
1214 trash->str[trash->len++] = hextab[c & 0xF];
1215 }
1216 smp->data.str = *trash;
1217 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001218 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001219 return 1;
1220}
1221
Willy Tarreau12785782012-04-27 21:37:17 +02001222static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +01001223{
1224 int i;
1225
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001226 if (!smp_dup(smp))
1227 return 0;
1228
Willy Tarreau342acb42012-04-23 22:03:39 +02001229 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001230 return 0;
1231
Willy Tarreau342acb42012-04-23 22:03:39 +02001232 for (i = 0; i < smp->data.str.len; i++) {
1233 if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z'))
1234 smp->data.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001235 }
1236 return 1;
1237}
1238
Willy Tarreau12785782012-04-27 21:37:17 +02001239static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +01001240{
1241 int i;
1242
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001243 if (!smp_dup(smp))
1244 return 0;
1245
Willy Tarreau342acb42012-04-23 22:03:39 +02001246 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001247 return 0;
1248
Willy Tarreau342acb42012-04-23 22:03:39 +02001249 for (i = 0; i < smp->data.str.len; i++) {
1250 if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z'))
1251 smp->data.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001252 }
1253 return 1;
1254}
1255
Willy Tarreauf9954102012-04-20 14:03:29 +02001256/* takes the netmask in arg_p */
Willy Tarreau12785782012-04-27 21:37:17 +02001257static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001258{
Willy Tarreau342acb42012-04-23 22:03:39 +02001259 smp->data.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001260 smp->type = SMP_T_IPV4;
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001261 return 1;
1262}
1263
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001264/************************************************************************/
1265/* All supported sample fetch functions must be declared here */
1266/************************************************************************/
1267
1268/* force TRUE to be returned at the fetch level */
1269static int
1270smp_fetch_true(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001271 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001272{
1273 smp->type = SMP_T_BOOL;
1274 smp->data.uint = 1;
1275 return 1;
1276}
1277
1278/* force FALSE to be returned at the fetch level */
1279static int
1280smp_fetch_false(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001281 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001282{
1283 smp->type = SMP_T_BOOL;
1284 smp->data.uint = 0;
1285 return 1;
1286}
1287
1288/* retrieve environment variable $1 as a string */
1289static int
1290smp_fetch_env(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001291 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001292{
1293 char *env;
1294
1295 if (!args || args[0].type != ARGT_STR)
1296 return 0;
1297
1298 env = getenv(args[0].data.str.str);
1299 if (!env)
1300 return 0;
1301
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001302 smp->type = SMP_T_STR;
1303 smp->flags = SMP_F_CONST;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001304 smp->data.str.str = env;
1305 smp->data.str.len = strlen(env);
1306 return 1;
1307}
1308
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001309/* retrieve the current local date in epoch time, and applies an optional offset
1310 * of args[0] seconds.
1311 */
1312static int
1313smp_fetch_date(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001314 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001315{
1316 smp->data.uint = date.tv_sec;
1317
1318 /* add offset */
1319 if (args && (args[0].type == ARGT_SINT || args[0].type == ARGT_UINT))
1320 smp->data.uint += args[0].data.sint;
1321
1322 smp->type = SMP_T_UINT;
1323 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
1324 return 1;
1325}
1326
Willy Tarreau84310e22014-02-14 11:59:04 +01001327/* generate a random 32-bit integer for whatever purpose, with an optional
1328 * range specified in argument.
1329 */
1330static int
1331smp_fetch_rand(struct proxy *px, struct session *s, void *l7, unsigned int opt,
1332 const struct arg *args, struct sample *smp, const char *kw)
1333{
1334 smp->data.uint = random();
1335
1336 /* reduce if needed. Don't do a modulo, use all bits! */
1337 if (args && args[0].type == ARGT_UINT)
1338 smp->data.uint = ((uint64_t)smp->data.uint * args[0].data.uint) >> 32;
1339
1340 smp->type = SMP_T_UINT;
1341 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
1342 return 1;
1343}
1344
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001345/* Note: must not be declared <const> as its list will be overwritten.
1346 * Note: fetches that may return multiple types must be declared as the lowest
1347 * common denominator, the type that can be casted into all other ones. For
1348 * instance IPv4/IPv6 must be declared IPv4.
1349 */
1350static struct sample_fetch_kw_list smp_kws = {ILH, {
1351 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
1352 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001353 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001354 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau84310e22014-02-14 11:59:04 +01001355 { "rand", smp_fetch_rand, ARG1(0,UINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001356 { /* END */ },
1357}};
1358
Emeric Brun107ca302010-01-04 16:16:05 +01001359/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001360static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Emeric Brun53d1a982014-04-30 18:21:37 +02001361 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02001362 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
1363 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001364 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02001365 { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02001366 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01001367}};
1368
1369__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02001370static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01001371{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001372 /* register sample fetch and format conversion keywords */
1373 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02001374 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01001375}