blob: 50ceb856a2deee0a17f3331ecc538d3a92ba85f2 [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>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020023
Willy Tarreau9fcb9842012-04-20 14:45:49 +020024#include <proto/arg.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020025#include <proto/auth.h>
26#include <proto/log.h>
27#include <proto/proxy.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020028#include <proto/sample.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020029#include <proto/stick_table.h>
Emeric Brun107ca302010-01-04 16:16:05 +010030
Willy Tarreau12785782012-04-27 21:37:17 +020031/* static sample used in sample_process() when <p> is NULL */
Willy Tarreaub4a88f02012-04-23 21:35:11 +020032static struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010033
Willy Tarreau12785782012-04-27 21:37:17 +020034/* list head of all known sample fetch keywords */
35static struct sample_fetch_kw_list sample_fetches = {
36 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010037};
38
Willy Tarreau12785782012-04-27 21:37:17 +020039/* list head of all known sample format conversion keywords */
40static struct sample_conv_kw_list sample_convs = {
41 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010042};
43
Willy Tarreau80aca902013-01-07 15:42:20 +010044const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
45 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
46 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
47 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
48 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
49 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
50 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
51 SMP_VAL_FE_LOG_END),
52
53 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
54 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
55 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
56 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
57 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
58 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
59 SMP_VAL_FE_LOG_END),
60
61 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
62 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
63 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
64 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
65 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
66 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
67 SMP_VAL_FE_LOG_END),
68
69 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
70 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
71 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
72 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
73 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
74 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
75 SMP_VAL_FE_LOG_END),
76
77 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
78 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
79 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
80 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
81 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
82 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
83 SMP_VAL_FE_LOG_END),
84
85 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
86 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
87 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
88 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
89 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
90 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
91 SMP_VAL_FE_LOG_END),
92
93 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
94 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
95 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
96 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
97 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
98 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
99 SMP_VAL___________),
100
101 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
102 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
103 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
104 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
105 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
106 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
107 SMP_VAL___________),
108
109 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
110 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
111 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
112 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
113 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
114 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
115 SMP_VAL_FE_LOG_END),
116
117 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
118 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
119 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
120 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
121 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
122 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
123 SMP_VAL___________),
124
125 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
126 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
127 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
128 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
129 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
130 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
131 SMP_VAL_FE_LOG_END),
132
133 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
134 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
135 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
136 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
137 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
138 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
139 SMP_VAL_FE_LOG_END),
140
141 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
142 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
143 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
144 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
145 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
146 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
147 SMP_VAL_FE_LOG_END),
148
149 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
150 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
151 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
152 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
153 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
154 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
155 SMP_VAL_FE_LOG_END),
156
157 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
158 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
159 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
160 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
161 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
162 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
163 SMP_VAL___________),
164
165 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
166 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
167 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
168 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
169 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
170 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
171 SMP_VAL___________),
172
173 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
174 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
175 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
176 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
177 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
178 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
179 SMP_VAL_FE_LOG_END),
180
181 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
182 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
183 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
184 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
185 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
186 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
187 SMP_VAL___________),
188
189 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
190 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
191 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
192 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
193 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
194 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
195 SMP_VAL_FE_LOG_END),
196
197 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
198 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
199 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
200 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
201 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
202 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
203 SMP_VAL_FE_LOG_END),
204
205 [SMP_SRC_TXFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
210 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
211 SMP_VAL_FE_LOG_END),
212
213 [SMP_SRC_SSFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
218 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL_FE_LOG_END),
220};
221
222static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
223 [SMP_SRC_INTRN] = "internal state",
224 [SMP_SRC_LISTN] = "listener",
225 [SMP_SRC_FTEND] = "frontend",
226 [SMP_SRC_L4CLI] = "client address",
227 [SMP_SRC_L5CLI] = "client-side connection",
228 [SMP_SRC_TRACK] = "track counters",
229 [SMP_SRC_L6REQ] = "request buffer",
230 [SMP_SRC_HRQHV] = "HTTP request headers",
231 [SMP_SRC_HRQHP] = "HTTP request",
232 [SMP_SRC_HRQBO] = "HTTP request body",
233 [SMP_SRC_BKEND] = "backend",
234 [SMP_SRC_SERVR] = "server",
235 [SMP_SRC_L4SRV] = "server address",
236 [SMP_SRC_L5SRV] = "server-side connection",
237 [SMP_SRC_L6RES] = "response buffer",
238 [SMP_SRC_HRSHV] = "HTTP response headers",
239 [SMP_SRC_HRSHP] = "HTTP response",
240 [SMP_SRC_HRSBO] = "HTTP response body",
241 [SMP_SRC_RQFIN] = "request buffer statistics",
242 [SMP_SRC_RSFIN] = "response buffer statistics",
243 [SMP_SRC_TXFIN] = "transaction statistics",
244 [SMP_SRC_SSFIN] = "session statistics",
245};
246
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100247static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
248 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
249 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
250 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
251 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
252 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
253 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
254 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
255 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
256 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
257 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
258 [SMP_CKP_BE_SRV_CON] = "server source selection",
259 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
260 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
261 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
262 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
263 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
264 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
265 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
266 [SMP_CKP_FE_LOG_END] = "logs",
267};
268
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100269/* This function returns the type of the data returned by the sample_expr.
270 * It assumes that the <expr> and all of its converters are properly
271 * initialized.
272 */
273inline
274int smp_expr_output_type(struct sample_expr *expr)
275{
276 struct sample_conv_expr *smp_expr;
277
278 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
279 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
280 return smp_expr->conv->out_type;
281 }
282 return expr->fetch->out_type;
283}
284
285
Willy Tarreau80aca902013-01-07 15:42:20 +0100286/* fill the trash with a comma-delimited list of source names for the <use> bit
287 * field which must be composed of a non-null set of SMP_USE_* flags. The return
288 * value is the pointer to the string in the trash buffer.
289 */
290const char *sample_src_names(unsigned int use)
291{
292 int bit;
293
294 trash.len = 0;
295 trash.str[0] = '\0';
296 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
297 if (!(use & ~((1 << bit) - 1)))
298 break; /* no more bits */
299
300 if (!(use & (1 << bit)))
301 continue; /* bit not set */
302
303 trash.len += snprintf(trash.str + trash.len, trash.size - trash.len, "%s%s",
304 (use & ((1 << bit) - 1)) ? "," : "",
305 fetch_src_names[bit]);
306 }
307 return trash.str;
308}
309
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100310/* return a pointer to the correct sample checkpoint name, or "unknown" when
311 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
312 * if set.
313 */
314const char *sample_ckp_names(unsigned int use)
315{
316 int bit;
317
318 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
319 if (use & (1 << bit))
320 return fetch_ckp_names[bit];
321 return "unknown sample check place, please report this bug";
322}
323
Emeric Brun107ca302010-01-04 16:16:05 +0100324/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100325 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
326 * for next parsing sessions. The fetch keywords capabilities are also computed
327 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100328 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100329void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100330{
Willy Tarreau80aca902013-01-07 15:42:20 +0100331 struct sample_fetch *sf;
332 int bit;
333
334 for (sf = kwl->kw; sf->kw != NULL; sf++) {
335 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
336 if (sf->use & (1 << bit))
337 sf->val |= fetch_cap[bit];
338 }
339 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100340}
341
342/*
Willy Tarreau12785782012-04-27 21:37:17 +0200343 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100344 * parsing sessions.
345 */
Willy Tarreau12785782012-04-27 21:37:17 +0200346void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100347{
Willy Tarreau12785782012-04-27 21:37:17 +0200348 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100349}
350
351/*
Willy Tarreau12785782012-04-27 21:37:17 +0200352 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100353 * string of <len> in buffer <kw>.
354 *
355 */
Willy Tarreau12785782012-04-27 21:37:17 +0200356struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100357{
358 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200359 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100360
Willy Tarreau12785782012-04-27 21:37:17 +0200361 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100362 for (index = 0; kwl->kw[index].kw != NULL; index++) {
363 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
364 kwl->kw[index].kw[len] == '\0')
365 return &kwl->kw[index];
366 }
367 }
368 return NULL;
369}
370
371/*
Willy Tarreau12785782012-04-27 21:37:17 +0200372 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100373 * string of <len> in buffer <kw>.
374 *
375 */
Willy Tarreau12785782012-04-27 21:37:17 +0200376struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100377{
378 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200379 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100380
Willy Tarreau12785782012-04-27 21:37:17 +0200381 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100382 for (index = 0; kwl->kw[index].kw != NULL; index++) {
383 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
384 kwl->kw[index].kw[len] == '\0')
385 return &kwl->kw[index];
386 }
387 }
388 return NULL;
389}
390
Emeric Brun107ca302010-01-04 16:16:05 +0100391/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200392/* Sample casts functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200393/* Note: these functions do *NOT* set the output type on the */
394/* sample, the caller is responsible for doing this on return. */
Emeric Brun107ca302010-01-04 16:16:05 +0100395/******************************************************************/
396
Willy Tarreau342acb42012-04-23 22:03:39 +0200397static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100398{
Willy Tarreau342acb42012-04-23 22:03:39 +0200399 smp->data.uint = ntohl(smp->data.ipv4.s_addr);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100400 smp->type = SMP_T_UINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100401 return 1;
402}
403
Willy Tarreau342acb42012-04-23 22:03:39 +0200404static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100405{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100406 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100407
Willy Tarreau342acb42012-04-23 22:03:39 +0200408 if (!inet_ntop(AF_INET, (void *)&smp->data.ipv4, trash->str, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100409 return 0;
410
411 trash->len = strlen(trash->str);
Willy Tarreau342acb42012-04-23 22:03:39 +0200412 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100413 smp->type = SMP_T_STR;
Emeric Brun107ca302010-01-04 16:16:05 +0100414
415 return 1;
416}
417
Willy Tarreau342acb42012-04-23 22:03:39 +0200418static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100419{
Willy Tarreau342acb42012-04-23 22:03:39 +0200420 v4tov6(&smp->data.ipv6, &smp->data.ipv4);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100421 smp->type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100422 return 1;
423}
424
Willy Tarreau342acb42012-04-23 22:03:39 +0200425static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100426{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100427 struct chunk *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100428
Willy Tarreau342acb42012-04-23 22:03:39 +0200429 if (!inet_ntop(AF_INET6, (void *)&smp->data.ipv6, trash->str, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100430 return 0;
431
432 trash->len = strlen(trash->str);
Willy Tarreau342acb42012-04-23 22:03:39 +0200433 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100434 smp->type = SMP_T_STR;
David du Colombier4f92d322011-03-24 11:09:31 +0100435 return 1;
436}
437
438/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200439static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100440{
Willy Tarreau342acb42012-04-23 22:03:39 +0200441 return v6tov4(&smp->data.ipv4, &smp->data.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100442}
443*/
444
Willy Tarreau342acb42012-04-23 22:03:39 +0200445static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100446{
Willy Tarreau342acb42012-04-23 22:03:39 +0200447 smp->data.ipv4.s_addr = htonl(smp->data.uint);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100448 smp->type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100449 return 1;
450}
451
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100452static int c_str2addr(struct sample *smp)
453{
454 int ret;
455
456 if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) {
457 ret = inet_pton(AF_INET6, smp->data.str.str, &smp->data.ipv6);
458 if (ret)
459 smp->type = SMP_T_IPV6;
460 return ret;
461 }
462 smp->type = SMP_T_IPV4;
463 return 1;
464}
465
Willy Tarreau342acb42012-04-23 22:03:39 +0200466static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100467{
Willy Tarreau342acb42012-04-23 22:03:39 +0200468 if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100469 return 0;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100470 smp->type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100471 return 1;
472}
473
Willy Tarreau342acb42012-04-23 22:03:39 +0200474static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100475{
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100476 int ret;
477
478 ret = inet_pton(AF_INET6, smp->data.str.str, &smp->data.ipv6);
479 if (ret)
480 smp->type = SMP_T_IPV6;
481 return ret;
David du Colombier4f92d322011-03-24 11:09:31 +0100482}
483
Emeric Brun8ac33d92012-10-17 13:36:06 +0200484static int c_bin2str(struct sample *smp)
485{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100486 struct chunk *trash = get_trash_chunk();
Emeric Brun8ac33d92012-10-17 13:36:06 +0200487 unsigned char c;
488 int ptr = 0;
489
490 trash->len = 0;
491 while (ptr < smp->data.str.len && trash->len <= trash->size - 2) {
492 c = smp->data.str.str[ptr++];
493 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
494 trash->str[trash->len++] = hextab[c & 0xF];
495 }
496 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100497 smp->type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200498 return 1;
499}
500
Willy Tarreau342acb42012-04-23 22:03:39 +0200501static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100502{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100503 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100504 char *pos;
505
Willy Tarreau342acb42012-04-23 22:03:39 +0200506 pos = ultoa_r(smp->data.uint, trash->str, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100507
508 if (!pos)
509 return 0;
510
Emeric Brun485479d2010-09-23 18:02:19 +0200511 trash->size = trash->size - (pos - trash->str);
Emeric Brun107ca302010-01-04 16:16:05 +0100512 trash->str = pos;
513 trash->len = strlen(pos);
Willy Tarreau342acb42012-04-23 22:03:39 +0200514 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100515 smp->type = SMP_T_STR;
Emeric Brun107ca302010-01-04 16:16:05 +0100516 return 1;
517}
518
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100519static inline void _c_datadup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200520{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100521 struct chunk *trash = get_trash_chunk();
Emeric Brun485479d2010-09-23 18:02:19 +0200522
Willy Tarreau342acb42012-04-23 22:03:39 +0200523 trash->len = smp->data.str.len < trash->size ? smp->data.str.len : trash->size;
524 memcpy(trash->str, smp->data.str.str, trash->len);
525 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100526}
527
528static int c_datadup(struct sample *smp)
529{
530 _c_datadup(smp);
531 if (smp->type == SMP_T_CSTR)
532 smp->type = SMP_T_STR;
533 else
534 smp->type = SMP_T_BIN;
535 return 1;
536}
537
538static int c_bindup(struct sample *smp)
539{
540 _c_datadup(smp);
541 smp->type = SMP_T_BIN;
Emeric Brun485479d2010-09-23 18:02:19 +0200542 return 1;
543}
544
545
Willy Tarreau342acb42012-04-23 22:03:39 +0200546static int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100547{
548 return 1;
549}
550
Willy Tarreau342acb42012-04-23 22:03:39 +0200551static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100552{
553 int i;
554 uint32_t ret = 0;
555
Willy Tarreau342acb42012-04-23 22:03:39 +0200556 for (i = 0; i < smp->data.str.len; i++) {
557 uint32_t val = smp->data.str.str[i] - '0';
Emeric Brun107ca302010-01-04 16:16:05 +0100558
559 if (val > 9)
560 break;
561
562 ret = ret * 10 + val;
563 }
564
Willy Tarreau342acb42012-04-23 22:03:39 +0200565 smp->data.uint = ret;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100566 smp->type = SMP_T_UINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100567 return 1;
568}
569
570/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200571/* Sample casts matrix: */
572/* sample_casts[from type][to type] */
573/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100574/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100575
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100576sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100577/* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN CSTR CBIN */
578/* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, c_int2str, NULL, },
579/* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, c_int2str, NULL, },
580/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, c_int2str, NULL, },
581/* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
582/* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, NULL, c_ip2str, NULL, },
583/* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, NULL, c_ipv62str, NULL, },
584/* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_none, c_none, },
585/* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_bin2str, c_none, },
586/* CSTR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_datadup, c_bindup, c_none, c_none, },
587/* CBIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_datadup, c_bin2str, c_none, },
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200588};
Emeric Brun107ca302010-01-04 16:16:05 +0100589
Emeric Brun107ca302010-01-04 16:16:05 +0100590/*
Willy Tarreau12785782012-04-27 21:37:17 +0200591 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100592 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200593 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200594 * The caller must have set al->ctx.
Emeric Brun107ca302010-01-04 16:16:05 +0100595 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200596struct sample_expr *sample_parse_expr(char **str, int *idx, char *err, int err_size, struct arg_list *al)
Emeric Brun107ca302010-01-04 16:16:05 +0100597{
Willy Tarreau833cc792013-07-24 15:34:19 +0200598 const char *begw; /* beginning of word */
599 const char *endw; /* end of word */
600 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200601 struct sample_expr *expr;
602 struct sample_fetch *fetch;
603 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100604 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200605 char *fkw = NULL;
606 char *ckw = NULL;
Emeric Brun107ca302010-01-04 16:16:05 +0100607
Willy Tarreau833cc792013-07-24 15:34:19 +0200608 /* prepare a generic message if any further snprintf() fails */
Emeric Brun485479d2010-09-23 18:02:19 +0200609 snprintf(err, err_size, "memory error.");
Emeric Brun485479d2010-09-23 18:02:19 +0200610
Willy Tarreau833cc792013-07-24 15:34:19 +0200611 begw = str[*idx];
612 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
613
614 if (endw == begw) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100615 snprintf(err, err_size, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100616 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200617 }
Emeric Brun107ca302010-01-04 16:16:05 +0100618
Willy Tarreau833cc792013-07-24 15:34:19 +0200619 /* keep a copy of the current fetch keyword for error reporting */
620 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100621
Willy Tarreau833cc792013-07-24 15:34:19 +0200622 fetch = find_sample_fetch(begw, endw - begw);
623 if (!fetch) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100624 snprintf(err, err_size, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100625 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200626 }
Emeric Brun107ca302010-01-04 16:16:05 +0100627
Willy Tarreau833cc792013-07-24 15:34:19 +0200628 endt = endw;
629 if (*endt == '(') {
630 /* look for the end of this term */
631 while (*endt && *endt != ')')
632 endt++;
633 if (*endt != ')') {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100634 snprintf(err, err_size, "syntax error: missing ')' after fetch keyword '%s'", fkw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200635 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200636 }
Emeric Brun485479d2010-09-23 18:02:19 +0200637 }
Emeric Brun107ca302010-01-04 16:16:05 +0100638
Willy Tarreau833cc792013-07-24 15:34:19 +0200639 /* At this point, we have :
640 * - begw : beginning of the keyword
641 * - endw : end of the keyword (points to next delimiter or '(')
642 * - endt : end of the term (=endw or last parenthesis if args are present)
643 */
644
645 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100646 snprintf(err, err_size, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100647 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200648 }
Emeric Brun107ca302010-01-04 16:16:05 +0100649 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200650
Willy Tarreau12785782012-04-27 21:37:17 +0200651 expr = calloc(1, sizeof(struct sample_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200652 if (!expr)
653 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100654
655 LIST_INIT(&(expr->conv_exprs));
656 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200657 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100658
Willy Tarreau833cc792013-07-24 15:34:19 +0200659 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200660 char *err_msg = NULL;
661 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200662
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200663 if (!fetch->arg_mask) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100664 snprintf(err, err_size, "fetch method '%s' does not support any args", fkw);
Emeric Brun485479d2010-09-23 18:02:19 +0200665 goto out_error;
666 }
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200667
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200668 al->kw = expr->fetch->kw;
669 al->conv = NULL;
Willy Tarreau833cc792013-07-24 15:34:19 +0200670 if (make_arg_list(endw + 1, endt - endw - 1, fetch->arg_mask, &expr->arg_p, &err_msg, NULL, &err_arg, al) < 0) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100671 snprintf(err, err_size, "invalid arg %d in fetch method '%s' : %s", err_arg+1, fkw, err_msg);
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200672 free(err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200673 goto out_error;
674 }
675
Willy Tarreau2e845be2012-10-19 19:49:09 +0200676 if (!expr->arg_p)
677 expr->arg_p = empty_arg_list;
678
Willy Tarreau21d68a62012-04-20 15:52:36 +0200679 if (fetch->val_args && !fetch->val_args(expr->arg_p, &err_msg)) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100680 snprintf(err, err_size, "invalid args in fetch method '%s' : %s", fkw, err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200681 free(err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200682 goto out_error;
683 }
684 }
Willy Tarreauf22a5082012-10-19 16:47:23 +0200685 else if (ARGM(fetch->arg_mask)) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100686 snprintf(err, err_size, "missing args for fetch method '%s'", fkw);
Emeric Brun485479d2010-09-23 18:02:19 +0200687 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100688 }
689
Willy Tarreau833cc792013-07-24 15:34:19 +0200690 /* Now process the converters if any. We have two supported syntaxes
691 * for the converters, which can be combined :
692 * - comma-delimited list of converters just after the keyword and args ;
693 * - one converter per keyword
694 * The combination allows to have each keyword being a comma-delimited
695 * series of converters.
696 *
697 * We want to process the former first, then the latter. For this we start
698 * from the beginning of the supposed place in the exiting conv chain, which
699 * starts at the last comma (endt).
700 */
701
702 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200703 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100704
Willy Tarreau833cc792013-07-24 15:34:19 +0200705 if (*endt == ')') /* skip last closing parenthesis */
706 endt++;
Emeric Brun107ca302010-01-04 16:16:05 +0100707
Willy Tarreau833cc792013-07-24 15:34:19 +0200708 if (*endt && *endt != ',') {
709 if (ckw)
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100710 snprintf(err, err_size, "missing comma after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200711 else
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100712 snprintf(err, err_size, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100713 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200714 }
Emeric Brun107ca302010-01-04 16:16:05 +0100715
Willy Tarreau833cc792013-07-24 15:34:19 +0200716 while (*endt == ',') /* then trailing commas */
717 endt++;
718
719 begw = endt; /* start of conv keyword */
720
721 if (!*begw) {
722 /* none ? skip to next string */
723 (*idx)++;
724 begw = str[*idx];
725 if (!begw || !*begw)
726 break;
727 }
728
729 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
730
731 free(ckw);
732 ckw = my_strndup(begw, endw - begw);
733
734 conv = find_sample_conv(begw, endw - begw);
735 if (!conv) {
736 /* we found an isolated keyword that we don't know, it's not ours */
737 if (begw == str[*idx])
738 break;
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100739 snprintf(err, err_size, "unknown conv method '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200740 goto out_error;
741 }
Emeric Brun107ca302010-01-04 16:16:05 +0100742
Willy Tarreau833cc792013-07-24 15:34:19 +0200743 endt = endw;
744 if (*endt == '(') {
745 /* look for the end of this term */
746 while (*endt && *endt != ')')
747 endt++;
748 if (*endt != ')') {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100749 snprintf(err, err_size, "syntax error: missing ')' after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200750 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200751 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200752 }
753
754 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100755 snprintf(err, err_size, "returns type of conv method '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100756 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200757 }
Emeric Brun107ca302010-01-04 16:16:05 +0100758
759 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200760 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100761 snprintf(err, err_size, "conv method '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100762 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200763 }
Emeric Brun107ca302010-01-04 16:16:05 +0100764
765 prev_type = conv->out_type;
Willy Tarreau12785782012-04-27 21:37:17 +0200766 conv_expr = calloc(1, sizeof(struct sample_conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200767 if (!conv_expr)
768 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100769
770 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
771 conv_expr->conv = conv;
772
Willy Tarreau833cc792013-07-24 15:34:19 +0200773 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200774 char *err_msg = NULL;
775 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200776
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200777 if (!conv->arg_mask) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100778 snprintf(err, err_size, "conv method '%s' does not support any args", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200779 goto out_error;
780 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100781
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200782 al->kw = expr->fetch->kw;
783 al->conv = conv_expr->conv->kw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200784 if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, &err_msg, NULL, &err_arg, al) < 0) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100785 snprintf(err, err_size, "invalid arg %d in conv method '%s' : %s", err_arg+1, ckw, err_msg);
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200786 free(err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200787 goto out_error;
788 }
789
Willy Tarreau2e845be2012-10-19 19:49:09 +0200790 if (!conv_expr->arg_p)
791 conv_expr->arg_p = empty_arg_list;
792
Thierry FOURNIER9c1d67e2013-11-21 13:37:41 +0100793 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, &err_msg)) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100794 snprintf(err, err_size, "invalid args in conv method '%s' : %s", ckw, err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200795 free(err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200796 goto out_error;
797 }
798 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200799 else if (ARGM(conv->arg_mask)) {
Willy Tarreau3d536ac2013-12-06 16:02:46 +0100800 snprintf(err, err_size, "missing args for conv method '%s'", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200801 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100802 }
803 }
Emeric Brun485479d2010-09-23 18:02:19 +0200804
Willy Tarreau833cc792013-07-24 15:34:19 +0200805 out:
806 free(fkw);
807 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100808 return expr;
809
810out_error:
Willy Tarreau12785782012-04-27 21:37:17 +0200811 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +0200812 expr = NULL;
813 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +0100814}
815
816/*
Willy Tarreau12785782012-04-27 21:37:17 +0200817 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +0200818 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +0200819 * Returns a pointer on a typed sample structure containing the result or NULL if
820 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +0100821 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +0200822 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200823 *
824 * Note: the fetch functions are required to properly set the return type. The
825 * conversion functions must do so too. However the cast functions do not need
826 * to since they're made to cast mutiple types according to what is required.
Emeric Brun107ca302010-01-04 16:16:05 +0100827 */
Willy Tarreau12785782012-04-27 21:37:17 +0200828struct sample *sample_process(struct proxy *px, struct session *l4, void *l7,
829 unsigned int opt,
830 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +0100831{
Willy Tarreau12785782012-04-27 21:37:17 +0200832 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100833
Willy Tarreau18387e22013-07-25 12:02:38 +0200834 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +0200835 p = &temp_smp;
Willy Tarreau18387e22013-07-25 12:02:38 +0200836 p->flags = 0;
837 }
Emeric Brun107ca302010-01-04 16:16:05 +0100838
Willy Tarreauef38c392013-07-22 16:29:32 +0200839 if (!expr->fetch->process(px, l4, l7, opt, expr->arg_p, p, expr->fetch->kw))
Emeric Brun107ca302010-01-04 16:16:05 +0100840 return NULL;
841
Emeric Brun107ca302010-01-04 16:16:05 +0100842 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +0200843 /* we want to ensure that p->type can be casted into
844 * conv_expr->conv->in_type. We have 3 possibilities :
845 * - NULL => not castable.
846 * - c_none => nothing to do (let's optimize it)
847 * - other => apply cast and prepare to fail
848 */
Willy Tarreau12785782012-04-27 21:37:17 +0200849 if (!sample_casts[p->type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +0200850 return NULL;
851
Willy Tarreau12785782012-04-27 21:37:17 +0200852 if (sample_casts[p->type][conv_expr->conv->in_type] != c_none &&
853 !sample_casts[p->type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +0100854 return NULL;
855
Willy Tarreau12e50112012-04-25 17:21:49 +0200856 /* OK cast succeeded */
857
Willy Tarreau342acb42012-04-23 22:03:39 +0200858 if (!conv_expr->conv->process(conv_expr->arg_p, p))
Emeric Brun107ca302010-01-04 16:16:05 +0100859 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +0100860 }
861 return p;
862}
863
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +0100864/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200865 * Resolve all remaining arguments in proxy <p>. Returns the number of
866 * errors or 0 if everything is fine.
867 */
868int smp_resolve_args(struct proxy *p)
869{
870 struct arg_list *cur, *bak;
871 const char *ctx, *where;
872 const char *conv_ctx, *conv_pre, *conv_pos;
873 struct userlist *ul;
874 struct arg *arg;
875 int cfgerr = 0;
876
877 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
878 struct proxy *px;
879 struct server *srv;
880 char *pname, *sname;
881
882 arg = cur->arg;
883
884 /* prepare output messages */
885 conv_pre = conv_pos = conv_ctx = "";
886 if (cur->conv) {
887 conv_ctx = cur->conv;
888 conv_pre = "conversion keyword '";
889 conv_pos = "' for ";
890 }
891
892 where = "in";
893 ctx = "sample fetch keyword";
894 switch (cur->ctx) {
895 case ARGC_STK:where = "in stick rule in"; break;
896 case ARGC_TRK: where = "in tracking rule in"; break;
897 case ARGC_LOG: where = "in log-format string in"; break;
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100898 case ARGC_HRQ: where = "in http-request header format string in"; break;
899 case ARGC_HRS: where = "in http-response header format string in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200900 case ARGC_UIF: where = "in unique-id-format string in"; break;
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +0100901 case ARGC_RDR: where = "in redirect format string in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200902 case ARGC_ACL: ctx = "ACL keyword"; break;
903 }
904
905 /* set a few default settings */
906 px = p;
907 pname = p->id;
908
909 switch (arg->type) {
910 case ARGT_SRV:
911 if (!arg->data.str.len) {
912 Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
913 cur->file, cur->line,
914 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
915 cfgerr++;
916 continue;
917 }
918
919 /* we support two formats : "bck/srv" and "srv" */
920 sname = strrchr(arg->data.str.str, '/');
921
922 if (sname) {
923 *sname++ = '\0';
924 pname = arg->data.str.str;
925
926 px = findproxy(pname, PR_CAP_BE);
927 if (!px) {
928 Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
929 cur->file, cur->line, pname,
930 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
931 cfgerr++;
932 break;
933 }
934 }
935 else
936 sname = arg->data.str.str;
937
938 srv = findserver(px, sname);
939 if (!srv) {
940 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",
941 cur->file, cur->line, sname, pname,
942 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
943 cfgerr++;
944 break;
945 }
946
947 free(arg->data.str.str);
948 arg->data.str.str = NULL;
949 arg->unresolved = 0;
950 arg->data.srv = srv;
951 break;
952
953 case ARGT_FE:
954 if (arg->data.str.len) {
955 pname = arg->data.str.str;
956 px = findproxy(pname, PR_CAP_FE);
957 }
958
959 if (!px) {
960 Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
961 cur->file, cur->line, pname,
962 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
963 cfgerr++;
964 break;
965 }
966
967 if (!(px->cap & PR_CAP_FE)) {
968 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
969 cur->file, cur->line, pname,
970 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
971 cfgerr++;
972 break;
973 }
974
975 free(arg->data.str.str);
976 arg->data.str.str = NULL;
977 arg->unresolved = 0;
978 arg->data.prx = px;
979 break;
980
981 case ARGT_BE:
982 if (arg->data.str.len) {
983 pname = arg->data.str.str;
984 px = findproxy(pname, PR_CAP_BE);
985 }
986
987 if (!px) {
988 Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
989 cur->file, cur->line, pname,
990 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
991 cfgerr++;
992 break;
993 }
994
995 if (!(px->cap & PR_CAP_BE)) {
996 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
997 cur->file, cur->line, pname,
998 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
999 cfgerr++;
1000 break;
1001 }
1002
1003 free(arg->data.str.str);
1004 arg->data.str.str = NULL;
1005 arg->unresolved = 0;
1006 arg->data.prx = px;
1007 break;
1008
1009 case ARGT_TAB:
1010 if (arg->data.str.len) {
1011 pname = arg->data.str.str;
1012 px = find_stktable(pname);
1013 }
1014
1015 if (!px) {
1016 Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1017 cur->file, cur->line, pname,
1018 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1019 cfgerr++;
1020 break;
1021 }
1022
1023 if (!px->table.size) {
1024 Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1025 cur->file, cur->line, pname,
1026 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1027 cfgerr++;
1028 break;
1029 }
1030
1031 free(arg->data.str.str);
1032 arg->data.str.str = NULL;
1033 arg->unresolved = 0;
1034 arg->data.prx = px;
1035 break;
1036
1037 case ARGT_USR:
1038 if (!arg->data.str.len) {
1039 Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1040 cur->file, cur->line,
1041 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1042 cfgerr++;
1043 break;
1044 }
1045
1046 if (p->uri_auth && p->uri_auth->userlist &&
1047 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1048 ul = p->uri_auth->userlist;
1049 else
1050 ul = auth_find_userlist(arg->data.str.str);
1051
1052 if (!ul) {
1053 Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1054 cur->file, cur->line, arg->data.str.str,
1055 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1056 cfgerr++;
1057 break;
1058 }
1059
1060 free(arg->data.str.str);
1061 arg->data.str.str = NULL;
1062 arg->unresolved = 0;
1063 arg->data.usr = ul;
1064 break;
1065 }
1066
1067 LIST_DEL(&cur->list);
1068 free(cur);
1069 } /* end of args processing */
1070
1071 return cfgerr;
1072}
1073
1074/*
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001075 * Process a fetch + format conversion as defined by the sample expression <expr>
1076 * on request or response considering the <opt> parameter. The output is always of
1077 * type string. Returns either NULL if no sample could be extracted, or a pointer
1078 * to the converted result stored in static temp_smp in format string.
1079 */
1080struct sample *sample_fetch_string(struct proxy *px, struct session *l4, void *l7,
1081 unsigned int opt, struct sample_expr *expr)
1082{
1083 struct sample *smp;
1084
1085 smp = sample_process(px, l4, l7, opt, expr, NULL);
1086 if (!smp)
1087 return NULL;
1088
1089 if (!sample_casts[smp->type][SMP_T_CSTR])
1090 return NULL;
1091
1092 if (!sample_casts[smp->type][SMP_T_CSTR](smp))
1093 return NULL;
1094
1095 smp->type = SMP_T_CSTR;
1096 return smp;
1097}
1098
Emeric Brun107ca302010-01-04 16:16:05 +01001099/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001100/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001101/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001102/*****************************************************************/
1103
Willy Tarreau12785782012-04-27 21:37:17 +02001104static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +01001105{
1106 int i;
1107
Willy Tarreau342acb42012-04-23 22:03:39 +02001108 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001109 return 0;
1110
Willy Tarreau342acb42012-04-23 22:03:39 +02001111 for (i = 0; i < smp->data.str.len; i++) {
1112 if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z'))
1113 smp->data.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001114 }
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001115 smp->type = SMP_T_STR;
Emeric Brun107ca302010-01-04 16:16:05 +01001116 return 1;
1117}
1118
Willy Tarreau12785782012-04-27 21:37:17 +02001119static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +01001120{
1121 int i;
1122
Willy Tarreau342acb42012-04-23 22:03:39 +02001123 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001124 return 0;
1125
Willy Tarreau342acb42012-04-23 22:03:39 +02001126 for (i = 0; i < smp->data.str.len; i++) {
1127 if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z'))
1128 smp->data.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001129 }
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001130 smp->type = SMP_T_STR;
Emeric Brun107ca302010-01-04 16:16:05 +01001131 return 1;
1132}
1133
Willy Tarreauf9954102012-04-20 14:03:29 +02001134/* takes the netmask in arg_p */
Willy Tarreau12785782012-04-27 21:37:17 +02001135static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001136{
Willy Tarreau342acb42012-04-23 22:03:39 +02001137 smp->data.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001138 smp->type = SMP_T_IPV4;
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001139 return 1;
1140}
1141
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001142/************************************************************************/
1143/* All supported sample fetch functions must be declared here */
1144/************************************************************************/
1145
1146/* force TRUE to be returned at the fetch level */
1147static int
1148smp_fetch_true(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001149 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001150{
1151 smp->type = SMP_T_BOOL;
1152 smp->data.uint = 1;
1153 return 1;
1154}
1155
1156/* force FALSE to be returned at the fetch level */
1157static int
1158smp_fetch_false(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001159 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001160{
1161 smp->type = SMP_T_BOOL;
1162 smp->data.uint = 0;
1163 return 1;
1164}
1165
1166/* retrieve environment variable $1 as a string */
1167static int
1168smp_fetch_env(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001169 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001170{
1171 char *env;
1172
1173 if (!args || args[0].type != ARGT_STR)
1174 return 0;
1175
1176 env = getenv(args[0].data.str.str);
1177 if (!env)
1178 return 0;
1179
1180 smp->type = SMP_T_CSTR;
1181 smp->data.str.str = env;
1182 smp->data.str.len = strlen(env);
1183 return 1;
1184}
1185
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001186/* retrieve the current local date in epoch time, and applies an optional offset
1187 * of args[0] seconds.
1188 */
1189static int
1190smp_fetch_date(struct proxy *px, struct session *s, void *l7, unsigned int opt,
Willy Tarreauef38c392013-07-22 16:29:32 +02001191 const struct arg *args, struct sample *smp, const char *kw)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001192{
1193 smp->data.uint = date.tv_sec;
1194
1195 /* add offset */
1196 if (args && (args[0].type == ARGT_SINT || args[0].type == ARGT_UINT))
1197 smp->data.uint += args[0].data.sint;
1198
1199 smp->type = SMP_T_UINT;
1200 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
1201 return 1;
1202}
1203
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001204/* Note: must not be declared <const> as its list will be overwritten.
1205 * Note: fetches that may return multiple types must be declared as the lowest
1206 * common denominator, the type that can be casted into all other ones. For
1207 * instance IPv4/IPv6 must be declared IPv4.
1208 */
1209static struct sample_fetch_kw_list smp_kws = {ILH, {
1210 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
1211 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
1212 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_CSTR, SMP_USE_INTRN },
Willy Tarreau6236d3a2013-07-25 14:28:25 +02001213 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001214 { /* END */ },
1215}};
1216
Emeric Brun107ca302010-01-04 16:16:05 +01001217/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001218static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau12785782012-04-27 21:37:17 +02001219 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
1220 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
1221 { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02001222 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01001223}};
1224
1225__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02001226static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01001227{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02001228 /* register sample fetch and format conversion keywords */
1229 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02001230 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01001231}