blob: 7b70f4d3c9ce560a7af7123e5ad79d048a3e23cb [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
Emeric Brun3e256e52014-11-03 18:17:10 +0100500/*
501 * The NULL char always enforces the end of string if it is met.
502 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100503 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200504static int c_bin2str(struct sample *smp)
505{
Emeric Brun3e256e52014-11-03 18:17:10 +0100506 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200507
Emeric Brun3e256e52014-11-03 18:17:10 +0100508 for (i = 0; i < smp->data.str.len; i++) {
509 if (!smp->data.str.str[i]) {
510 smp->data.str.len = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100511 break;
Emeric Brun3e256e52014-11-03 18:17:10 +0100512 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200513 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200514 return 1;
515}
516
Willy Tarreau342acb42012-04-23 22:03:39 +0200517static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100518{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100519 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100520 char *pos;
521
Willy Tarreau342acb42012-04-23 22:03:39 +0200522 pos = ultoa_r(smp->data.uint, trash->str, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100523
524 if (!pos)
525 return 0;
526
Emeric Brun485479d2010-09-23 18:02:19 +0200527 trash->size = trash->size - (pos - trash->str);
Emeric Brun107ca302010-01-04 16:16:05 +0100528 trash->str = pos;
529 trash->len = strlen(pos);
Willy Tarreau342acb42012-04-23 22:03:39 +0200530 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100531 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100532 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100533 return 1;
534}
535
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100536/* This function duplicates data and removes the flag "const". */
537int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200538{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100539 struct chunk *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200540
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100541 /* If the const flag is not set, we don't need to duplicate the
542 * pattern as it can be modified in place.
543 */
544 if (!(smp->flags & SMP_F_CONST))
545 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100546
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100547 switch (smp->type) {
548 case SMP_T_BOOL:
549 case SMP_T_UINT:
550 case SMP_T_SINT:
551 case SMP_T_ADDR:
552 case SMP_T_IPV4:
553 case SMP_T_IPV6:
554 /* These type are not const. */
555 break;
556 case SMP_T_STR:
557 case SMP_T_BIN:
558 /* Duplicate data. */
559 trash = get_trash_chunk();
560 trash->len = smp->data.str.len < trash->size ? smp->data.str.len : trash->size;
561 memcpy(trash->str, smp->data.str.str, trash->len);
562 smp->data.str = *trash;
563 break;
564 default:
565 /* Other cases are unexpected. */
566 return 0;
567 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100568
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100569 /* remove const flag */
570 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200571 return 1;
572}
573
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100574int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100575{
576 return 1;
577}
578
Willy Tarreau342acb42012-04-23 22:03:39 +0200579static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100580{
581 int i;
582 uint32_t ret = 0;
583
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100584 if (smp->data.str.len == 0)
585 return 0;
586
Willy Tarreau342acb42012-04-23 22:03:39 +0200587 for (i = 0; i < smp->data.str.len; i++) {
588 uint32_t val = smp->data.str.str[i] - '0';
Emeric Brun107ca302010-01-04 16:16:05 +0100589
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100590 if (val > 9) {
591 if (i == 0)
592 return 0;
Emeric Brun107ca302010-01-04 16:16:05 +0100593 break;
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100594 }
Emeric Brun107ca302010-01-04 16:16:05 +0100595
596 ret = ret * 10 + val;
597 }
598
Willy Tarreau342acb42012-04-23 22:03:39 +0200599 smp->data.uint = ret;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100600 smp->type = SMP_T_UINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100601 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100602 return 1;
603}
604
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100605static int c_str2meth(struct sample *smp)
606{
607 enum http_meth_t meth;
608 int len;
609
610 meth = find_http_meth(smp->data.str.str, smp->data.str.len);
611 if (meth == HTTP_METH_OTHER) {
612 len = smp->data.str.len;
613 smp->data.meth.str.str = smp->data.str.str;
614 smp->data.meth.str.len = len;
615 }
616 else
617 smp->flags &= ~SMP_F_CONST;
618 smp->data.meth.meth = meth;
619 smp->type = SMP_T_METH;
620 return 1;
621}
622
623static int c_meth2str(struct sample *smp)
624{
625 int len;
626 enum http_meth_t meth;
627
628 if (smp->data.meth.meth == HTTP_METH_OTHER) {
629 /* The method is unknown. Copy the original pointer. */
630 len = smp->data.meth.str.len;
631 smp->data.str.str = smp->data.meth.str.str;
632 smp->data.str.len = len;
633 smp->type = SMP_T_STR;
634 }
635 else if (smp->data.meth.meth < HTTP_METH_OTHER) {
636 /* The method is known, copy the pointer containing the string. */
637 meth = smp->data.meth.meth;
638 smp->data.str.str = http_known_methods[meth].name;
639 smp->data.str.len = http_known_methods[meth].len;
640 smp->flags |= SMP_F_CONST;
641 smp->type = SMP_T_STR;
642 }
643 else {
644 /* Unknown method */
645 return 0;
646 }
647 return 1;
648}
649
Emeric Brun107ca302010-01-04 16:16:05 +0100650/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200651/* Sample casts matrix: */
652/* sample_casts[from type][to type] */
653/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100654/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100655
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100656sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100657/* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN METH */
658/* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
659/* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, NULL, },
660/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, NULL, },
661/* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
662/* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, NULL, NULL, },
663/* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, NULL, NULL, },
664/* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
665/* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
666/* METH */ { NULL, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, },
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200667};
Emeric Brun107ca302010-01-04 16:16:05 +0100668
Emeric Brun107ca302010-01-04 16:16:05 +0100669/*
Willy Tarreau12785782012-04-27 21:37:17 +0200670 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100671 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200672 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200673 * The caller must have set al->ctx.
Emeric Brun107ca302010-01-04 16:16:05 +0100674 */
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100675struct 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 +0100676{
Willy Tarreau833cc792013-07-24 15:34:19 +0200677 const char *begw; /* beginning of word */
678 const char *endw; /* end of word */
679 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200680 struct sample_expr *expr;
681 struct sample_fetch *fetch;
682 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100683 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200684 char *fkw = NULL;
685 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100686 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100687
Willy Tarreau833cc792013-07-24 15:34:19 +0200688 begw = str[*idx];
689 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
690
691 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100692 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100693 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200694 }
Emeric Brun107ca302010-01-04 16:16:05 +0100695
Willy Tarreau833cc792013-07-24 15:34:19 +0200696 /* keep a copy of the current fetch keyword for error reporting */
697 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100698
Willy Tarreau833cc792013-07-24 15:34:19 +0200699 fetch = find_sample_fetch(begw, endw - begw);
700 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100701 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100702 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200703 }
Emeric Brun107ca302010-01-04 16:16:05 +0100704
Willy Tarreau833cc792013-07-24 15:34:19 +0200705 endt = endw;
706 if (*endt == '(') {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100707 /* look for the end of this term and skip the opening parenthesis */
708 endt = ++endw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200709 while (*endt && *endt != ')')
710 endt++;
711 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100712 memprintf(err_msg, "missing closing ')' after arguments to fetch keyword '%s'", fkw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200713 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200714 }
Emeric Brun485479d2010-09-23 18:02:19 +0200715 }
Emeric Brun107ca302010-01-04 16:16:05 +0100716
Willy Tarreau833cc792013-07-24 15:34:19 +0200717 /* At this point, we have :
718 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100719 * - endw : end of the keyword, first character not part of keyword
720 * nor the opening parenthesis (so first character of args
721 * if present).
Willy Tarreau833cc792013-07-24 15:34:19 +0200722 * - endt : end of the term (=endw or last parenthesis if args are present)
723 */
724
725 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100726 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100727 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200728 }
Emeric Brun107ca302010-01-04 16:16:05 +0100729 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200730
Willy Tarreau12785782012-04-27 21:37:17 +0200731 expr = calloc(1, sizeof(struct sample_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200732 if (!expr)
733 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100734
735 LIST_INIT(&(expr->conv_exprs));
736 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200737 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100738
Willy Tarreau689a1df2013-12-13 00:40:11 +0100739 /* Note that we call the argument parser even with an empty string,
740 * this allows it to automatically create entries for mandatory
741 * implicit arguments (eg: local proxy name).
742 */
743 al->kw = expr->fetch->kw;
744 al->conv = NULL;
745 if (make_arg_list(endw, endt - endw, fetch->arg_mask, &expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
746 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
747 goto out_error;
748 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200749
Willy Tarreau689a1df2013-12-13 00:40:11 +0100750 if (!expr->arg_p) {
751 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200752 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100753 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
754 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200755 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100756 }
757
Willy Tarreau833cc792013-07-24 15:34:19 +0200758 /* Now process the converters if any. We have two supported syntaxes
759 * for the converters, which can be combined :
760 * - comma-delimited list of converters just after the keyword and args ;
761 * - one converter per keyword
762 * The combination allows to have each keyword being a comma-delimited
763 * series of converters.
764 *
765 * We want to process the former first, then the latter. For this we start
766 * from the beginning of the supposed place in the exiting conv chain, which
767 * starts at the last comma (endt).
768 */
769
770 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200771 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100772
Willy Tarreau833cc792013-07-24 15:34:19 +0200773 if (*endt == ')') /* skip last closing parenthesis */
774 endt++;
Emeric Brun107ca302010-01-04 16:16:05 +0100775
Willy Tarreau833cc792013-07-24 15:34:19 +0200776 if (*endt && *endt != ',') {
777 if (ckw)
Willy Tarreau975c1782013-12-12 23:16:54 +0100778 memprintf(err_msg, "missing comma after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200779 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100780 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100781 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200782 }
Emeric Brun107ca302010-01-04 16:16:05 +0100783
Willy Tarreau833cc792013-07-24 15:34:19 +0200784 while (*endt == ',') /* then trailing commas */
785 endt++;
786
787 begw = endt; /* start of conv keyword */
788
789 if (!*begw) {
790 /* none ? skip to next string */
791 (*idx)++;
792 begw = str[*idx];
793 if (!begw || !*begw)
794 break;
795 }
796
797 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
798
799 free(ckw);
800 ckw = my_strndup(begw, endw - begw);
801
802 conv = find_sample_conv(begw, endw - begw);
803 if (!conv) {
804 /* we found an isolated keyword that we don't know, it's not ours */
805 if (begw == str[*idx])
806 break;
Willy Tarreau975c1782013-12-12 23:16:54 +0100807 memprintf(err_msg, "unknown conv method '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200808 goto out_error;
809 }
Emeric Brun107ca302010-01-04 16:16:05 +0100810
Willy Tarreau833cc792013-07-24 15:34:19 +0200811 endt = endw;
812 if (*endt == '(') {
813 /* look for the end of this term */
814 while (*endt && *endt != ')')
815 endt++;
816 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100817 memprintf(err_msg, "syntax error: missing ')' after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200818 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200819 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200820 }
821
822 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100823 memprintf(err_msg, "returns type of conv method '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100824 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200825 }
Emeric Brun107ca302010-01-04 16:16:05 +0100826
827 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200828 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100829 memprintf(err_msg, "conv method '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100830 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200831 }
Emeric Brun107ca302010-01-04 16:16:05 +0100832
833 prev_type = conv->out_type;
Willy Tarreau12785782012-04-27 21:37:17 +0200834 conv_expr = calloc(1, sizeof(struct sample_conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200835 if (!conv_expr)
836 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100837
838 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
839 conv_expr->conv = conv;
840
Willy Tarreau833cc792013-07-24 15:34:19 +0200841 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200842 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200843
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200844 if (!conv->arg_mask) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100845 memprintf(err_msg, "conv method '%s' does not support any args", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200846 goto out_error;
847 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100848
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200849 al->kw = expr->fetch->kw;
850 al->conv = conv_expr->conv->kw;
Willy Tarreau975c1782013-12-12 23:16:54 +0100851 if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
852 memprintf(err_msg, "invalid arg %d in conv method '%s' : %s", err_arg+1, ckw, *err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200853 goto out_error;
854 }
855
Willy Tarreau2e845be2012-10-19 19:49:09 +0200856 if (!conv_expr->arg_p)
857 conv_expr->arg_p = empty_arg_list;
858
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100859 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100860 memprintf(err_msg, "invalid args in conv method '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200861 goto out_error;
862 }
863 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200864 else if (ARGM(conv->arg_mask)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100865 memprintf(err_msg, "missing args for conv method '%s'", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200866 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100867 }
868 }
Emeric Brun485479d2010-09-23 18:02:19 +0200869
Willy Tarreau833cc792013-07-24 15:34:19 +0200870 out:
871 free(fkw);
872 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100873 return expr;
874
875out_error:
Willy Tarreau12785782012-04-27 21:37:17 +0200876 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +0200877 expr = NULL;
878 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +0100879}
880
881/*
Willy Tarreau12785782012-04-27 21:37:17 +0200882 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +0200883 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +0200884 * Returns a pointer on a typed sample structure containing the result or NULL if
885 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +0100886 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +0200887 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200888 *
889 * Note: the fetch functions are required to properly set the return type. The
890 * conversion functions must do so too. However the cast functions do not need
891 * to since they're made to cast mutiple types according to what is required.
Willy Tarreauf94735e2014-07-30 08:56:35 +0200892 *
893 * The caller may indicate in <opt> if it considers the result final or not.
894 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
895 * if the result is stable or not, according to the following table :
896 *
897 * return MAY_CHANGE FINAL Meaning for the sample
898 * NULL 0 * Not present and will never be (eg: header)
899 * NULL 1 0 Not present yet, could change (eg: POST param)
900 * NULL 1 1 Not present yet, will not change anymore
901 * smp 0 * Present and will not change (eg: header)
902 * smp 1 0 Present, may change (eg: request length)
903 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +0100904 */
Willy Tarreau12785782012-04-27 21:37:17 +0200905struct sample *sample_process(struct proxy *px, struct session *l4, void *l7,
906 unsigned int opt,
907 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +0100908{
Willy Tarreau12785782012-04-27 21:37:17 +0200909 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100910
Willy Tarreau18387e22013-07-25 12:02:38 +0200911 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +0200912 p = &temp_smp;
Willy Tarreaua4ba9db2014-06-25 16:56:41 +0200913 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +0200914 }
Emeric Brun107ca302010-01-04 16:16:05 +0100915
Willy Tarreauef38c392013-07-22 16:29:32 +0200916 if (!expr->fetch->process(px, l4, l7, opt, expr->arg_p, p, expr->fetch->kw))
Emeric Brun107ca302010-01-04 16:16:05 +0100917 return NULL;
918
Emeric Brun107ca302010-01-04 16:16:05 +0100919 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +0200920 /* we want to ensure that p->type can be casted into
921 * conv_expr->conv->in_type. We have 3 possibilities :
922 * - NULL => not castable.
923 * - c_none => nothing to do (let's optimize it)
924 * - other => apply cast and prepare to fail
925 */
Willy Tarreau12785782012-04-27 21:37:17 +0200926 if (!sample_casts[p->type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +0200927 return NULL;
928
Willy Tarreau12785782012-04-27 21:37:17 +0200929 if (sample_casts[p->type][conv_expr->conv->in_type] != c_none &&
930 !sample_casts[p->type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +0100931 return NULL;
932
Willy Tarreau12e50112012-04-25 17:21:49 +0200933 /* OK cast succeeded */
934
Willy Tarreau342acb42012-04-23 22:03:39 +0200935 if (!conv_expr->conv->process(conv_expr->arg_p, p))
Emeric Brun107ca302010-01-04 16:16:05 +0100936 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +0100937 }
938 return p;
939}
940
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +0100941/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200942 * Resolve all remaining arguments in proxy <p>. Returns the number of
943 * errors or 0 if everything is fine.
944 */
945int smp_resolve_args(struct proxy *p)
946{
947 struct arg_list *cur, *bak;
948 const char *ctx, *where;
949 const char *conv_ctx, *conv_pre, *conv_pos;
950 struct userlist *ul;
951 struct arg *arg;
952 int cfgerr = 0;
953
954 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
955 struct proxy *px;
956 struct server *srv;
957 char *pname, *sname;
958
959 arg = cur->arg;
960
961 /* prepare output messages */
962 conv_pre = conv_pos = conv_ctx = "";
963 if (cur->conv) {
964 conv_ctx = cur->conv;
965 conv_pre = "conversion keyword '";
966 conv_pos = "' for ";
967 }
968
969 where = "in";
970 ctx = "sample fetch keyword";
971 switch (cur->ctx) {
972 case ARGC_STK:where = "in stick rule in"; break;
973 case ARGC_TRK: where = "in tracking rule in"; break;
974 case ARGC_LOG: where = "in log-format string in"; break;
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100975 case ARGC_HRQ: where = "in http-request header format string in"; break;
976 case ARGC_HRS: where = "in http-response header format string in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200977 case ARGC_UIF: where = "in unique-id-format string in"; break;
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +0100978 case ARGC_RDR: where = "in redirect format string in"; break;
Willy Tarreau3a4ac422014-06-13 16:17:14 +0200979 case ARGC_CAP: where = "in capture rule in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200980 case ARGC_ACL: ctx = "ACL keyword"; break;
981 }
982
983 /* set a few default settings */
984 px = p;
985 pname = p->id;
986
987 switch (arg->type) {
988 case ARGT_SRV:
989 if (!arg->data.str.len) {
990 Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
991 cur->file, cur->line,
992 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
993 cfgerr++;
994 continue;
995 }
996
997 /* we support two formats : "bck/srv" and "srv" */
998 sname = strrchr(arg->data.str.str, '/');
999
1000 if (sname) {
1001 *sname++ = '\0';
1002 pname = arg->data.str.str;
1003
1004 px = findproxy(pname, PR_CAP_BE);
1005 if (!px) {
1006 Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1007 cur->file, cur->line, pname,
1008 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1009 cfgerr++;
1010 break;
1011 }
1012 }
1013 else
1014 sname = arg->data.str.str;
1015
1016 srv = findserver(px, sname);
1017 if (!srv) {
1018 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",
1019 cur->file, cur->line, sname, pname,
1020 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1021 cfgerr++;
1022 break;
1023 }
1024
1025 free(arg->data.str.str);
1026 arg->data.str.str = NULL;
1027 arg->unresolved = 0;
1028 arg->data.srv = srv;
1029 break;
1030
1031 case ARGT_FE:
1032 if (arg->data.str.len) {
1033 pname = arg->data.str.str;
1034 px = findproxy(pname, PR_CAP_FE);
1035 }
1036
1037 if (!px) {
1038 Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1039 cur->file, cur->line, pname,
1040 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1041 cfgerr++;
1042 break;
1043 }
1044
1045 if (!(px->cap & PR_CAP_FE)) {
1046 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1047 cur->file, cur->line, pname,
1048 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1049 cfgerr++;
1050 break;
1051 }
1052
1053 free(arg->data.str.str);
1054 arg->data.str.str = NULL;
1055 arg->unresolved = 0;
1056 arg->data.prx = px;
1057 break;
1058
1059 case ARGT_BE:
1060 if (arg->data.str.len) {
1061 pname = arg->data.str.str;
1062 px = findproxy(pname, PR_CAP_BE);
1063 }
1064
1065 if (!px) {
1066 Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1067 cur->file, cur->line, pname,
1068 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1069 cfgerr++;
1070 break;
1071 }
1072
1073 if (!(px->cap & PR_CAP_BE)) {
1074 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1075 cur->file, cur->line, pname,
1076 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1077 cfgerr++;
1078 break;
1079 }
1080
1081 free(arg->data.str.str);
1082 arg->data.str.str = NULL;
1083 arg->unresolved = 0;
1084 arg->data.prx = px;
1085 break;
1086
1087 case ARGT_TAB:
1088 if (arg->data.str.len) {
1089 pname = arg->data.str.str;
1090 px = find_stktable(pname);
1091 }
1092
1093 if (!px) {
1094 Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1095 cur->file, cur->line, pname,
1096 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1097 cfgerr++;
1098 break;
1099 }
1100
1101 if (!px->table.size) {
1102 Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1103 cur->file, cur->line, pname,
1104 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1105 cfgerr++;
1106 break;
1107 }
1108
1109 free(arg->data.str.str);
1110 arg->data.str.str = NULL;
1111 arg->unresolved = 0;
1112 arg->data.prx = px;
1113 break;
1114
1115 case ARGT_USR:
1116 if (!arg->data.str.len) {
1117 Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1118 cur->file, cur->line,
1119 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1120 cfgerr++;
1121 break;
1122 }
1123
1124 if (p->uri_auth && p->uri_auth->userlist &&
1125 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1126 ul = p->uri_auth->userlist;
1127 else
1128 ul = auth_find_userlist(arg->data.str.str);
1129
1130 if (!ul) {
1131 Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1132 cur->file, cur->line, arg->data.str.str,
1133 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1134 cfgerr++;
1135 break;
1136 }
1137
1138 free(arg->data.str.str);
1139 arg->data.str.str = NULL;
1140 arg->unresolved = 0;
1141 arg->data.usr = ul;
1142 break;
1143 }
1144
1145 LIST_DEL(&cur->list);
1146 free(cur);
1147 } /* end of args processing */
1148
1149 return cfgerr;
1150}
1151
1152/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001153 * Process a fetch + format conversion as defined by the sample expression
1154 * <expr> on request or response considering the <opt> parameter. The output is
1155 * always of type string. If a stable sample can be fetched, or an unstable one
1156 * when <opt> contains SMP_OPT_FINAL, the sample is converted to a string and
1157 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1158 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1159 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1160 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreauf94735e2014-07-30 08:56:35 +02001161 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1162 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1163 * still hope to get it after waiting longer, and is not converted to string.
1164 * The possible output combinations are the following :
1165 *
1166 * return MAY_CHANGE FINAL Meaning for the sample
1167 * NULL * * Not present and will never be (eg: header)
1168 * smp 0 * Final value converted (eg: header)
1169 * smp 1 0 Not present yet, may appear later (eg: header)
1170 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001171 */
1172struct sample *sample_fetch_string(struct proxy *px, struct session *l4, void *l7,
1173 unsigned int opt, struct sample_expr *expr)
1174{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001175 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001176
Willy Tarreaua4ba9db2014-06-25 16:56:41 +02001177 memset(smp, 0, sizeof(*smp));
1178
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001179 if (!sample_process(px, l4, l7, opt, expr, smp)) {
1180 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1181 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001182 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001183 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001184
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001185 if (!sample_casts[smp->type][SMP_T_STR])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001186 return NULL;
1187
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001188 if (!sample_casts[smp->type][SMP_T_STR](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001189 return NULL;
1190
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001191 smp->type = SMP_T_STR;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001192 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001193 return smp;
1194}
1195
Emeric Brun107ca302010-01-04 16:16:05 +01001196/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001197/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001198/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001199/*****************************************************************/
1200
Emeric Brun53d1a982014-04-30 18:21:37 +02001201static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp)
1202{
1203 struct chunk *trash = get_trash_chunk();
1204 int b64_len;
1205
1206 trash->len = 0;
1207 b64_len = a2base64(smp->data.str.str, smp->data.str.len, trash->str, trash->size);
1208 if (b64_len < 0)
1209 return 0;
1210
1211 trash->len = b64_len;
1212 smp->data.str = *trash;
1213 smp->type = SMP_T_STR;
1214 smp->flags &= ~SMP_F_CONST;
1215 return 1;
1216}
1217
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001218static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp)
1219{
1220 struct chunk *trash = get_trash_chunk();
1221 unsigned char c;
1222 int ptr = 0;
1223
1224 trash->len = 0;
1225 while (ptr < smp->data.str.len && trash->len <= trash->size - 2) {
1226 c = smp->data.str.str[ptr++];
1227 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
1228 trash->str[trash->len++] = hextab[c & 0xF];
1229 }
1230 smp->data.str = *trash;
1231 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001232 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001233 return 1;
1234}
1235
Willy Tarreau12785782012-04-27 21:37:17 +02001236static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +01001237{
1238 int i;
1239
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001240 if (!smp_dup(smp))
1241 return 0;
1242
Willy Tarreau342acb42012-04-23 22:03:39 +02001243 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001244 return 0;
1245
Willy Tarreau342acb42012-04-23 22:03:39 +02001246 for (i = 0; i < smp->data.str.len; i++) {
1247 if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z'))
1248 smp->data.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001249 }
1250 return 1;
1251}
1252
Willy Tarreau12785782012-04-27 21:37:17 +02001253static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +01001254{
1255 int i;
1256
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001257 if (!smp_dup(smp))
1258 return 0;
1259
Willy Tarreau342acb42012-04-23 22:03:39 +02001260 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001261 return 0;
1262
Willy Tarreau342acb42012-04-23 22:03:39 +02001263 for (i = 0; i < smp->data.str.len; i++) {
1264 if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z'))
1265 smp->data.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001266 }
1267 return 1;
1268}
1269
Willy Tarreauf9954102012-04-20 14:03:29 +02001270/* takes the netmask in arg_p */
Willy Tarreau12785782012-04-27 21:37:17 +02001271static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001272{
Willy Tarreau342acb42012-04-23 22:03:39 +02001273 smp->data.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001274 smp->type = SMP_T_IPV4;
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001275 return 1;
1276}
1277
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001278/************************************************************************/
1279/* All supported sample fetch functions must be declared here */
1280/************************************************************************/
1281
1282/* force TRUE to be returned at the fetch level */
1283static int
1284smp_fetch_true(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001285 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001286{
1287 smp->type = SMP_T_BOOL;
1288 smp->data.uint = 1;
1289 return 1;
1290}
1291
1292/* force FALSE to be returned at the fetch level */
1293static int
1294smp_fetch_false(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001295 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001296{
1297 smp->type = SMP_T_BOOL;
1298 smp->data.uint = 0;
1299 return 1;
1300}
1301
1302/* retrieve environment variable $1 as a string */
1303static int
1304smp_fetch_env(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001305 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001306{
1307 char *env;
1308
1309 if (!args || args[0].type != ARGT_STR)
1310 return 0;
1311
1312 env = getenv(args[0].data.str.str);
1313 if (!env)
1314 return 0;
1315
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001316 smp->type = SMP_T_STR;
1317 smp->flags = SMP_F_CONST;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001318 smp->data.str.str = env;
1319 smp->data.str.len = strlen(env);
1320 return 1;
1321}
1322
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001323/* retrieve the current local date in epoch time, and applies an optional offset
1324 * of args[0] seconds.
1325 */
1326static int
1327smp_fetch_date(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001328 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001329{
1330 smp->data.uint = date.tv_sec;
1331
1332 /* add offset */
1333 if (args && (args[0].type == ARGT_SINT || args[0].type == ARGT_UINT))
1334 smp->data.uint += args[0].data.sint;
1335
1336 smp->type = SMP_T_UINT;
1337 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
1338 return 1;
1339}
1340
Willy Tarreau84310e22014-02-14 11:59:04 +01001341/* generate a random 32-bit integer for whatever purpose, with an optional
1342 * range specified in argument.
1343 */
1344static int
1345smp_fetch_rand(struct proxy *px, struct session *s, void *l7, unsigned int opt,
1346 const struct arg *args, struct sample *smp, const char *kw)
1347{
1348 smp->data.uint = random();
1349
1350 /* reduce if needed. Don't do a modulo, use all bits! */
1351 if (args && args[0].type == ARGT_UINT)
1352 smp->data.uint = ((uint64_t)smp->data.uint * args[0].data.uint) >> 32;
1353
1354 smp->type = SMP_T_UINT;
1355 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
1356 return 1;
1357}
1358
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001359/* Note: must not be declared <const> as its list will be overwritten.
1360 * Note: fetches that may return multiple types must be declared as the lowest
1361 * common denominator, the type that can be casted into all other ones. For
1362 * instance IPv4/IPv6 must be declared IPv4.
1363 */
1364static struct sample_fetch_kw_list smp_kws = {ILH, {
1365 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
1366 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001367 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001368 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau84310e22014-02-14 11:59:04 +01001369 { "rand", smp_fetch_rand, ARG1(0,UINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001370 { /* END */ },
1371}};
1372
Emeric Brun107ca302010-01-04 16:16:05 +01001373/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001374static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Emeric Brun53d1a982014-04-30 18:21:37 +02001375 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02001376 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
1377 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001378 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02001379 { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02001380 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01001381}};
1382
1383__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02001384static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01001385{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001386 /* register sample fetch and format conversion keywords */
1387 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02001388 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01001389}