blob: c1d5bb5d45702f420570c1072813c20a66e2616e [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
Thierry FOURNIER317e1c42014-08-12 10:20:47 +020014#include <ctype.h>
Emeric Brun107ca302010-01-04 16:16:05 +010015#include <string.h>
16#include <arpa/inet.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020017#include <stdio.h>
Emeric Brun107ca302010-01-04 16:16:05 +010018
Willy Tarreau7e2c6472012-10-29 20:44:36 +010019#include <types/global.h>
20
Willy Tarreauc7e42382012-08-24 19:22:53 +020021#include <common/chunk.h>
Willy Tarreau23ec4ca2014-07-15 20:15:37 +020022#include <common/hash.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020023#include <common/standard.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020024#include <common/uri_auth.h>
Emeric Brun53d1a982014-04-30 18:21:37 +020025#include <common/base64.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020026
Willy Tarreau9fcb9842012-04-20 14:45:49 +020027#include <proto/arg.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020028#include <proto/auth.h>
29#include <proto/log.h>
Thierry FOURNIERd4373142013-12-17 01:10:10 +010030#include <proto/proto_http.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020031#include <proto/proxy.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020032#include <proto/sample.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020033#include <proto/stick_table.h>
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +020034#include <proto/vars.h>
Emeric Brun107ca302010-01-04 16:16:05 +010035
Willy Tarreau1cf8f082014-02-07 12:14:54 +010036/* sample type names */
37const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020038 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010039 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010040 [SMP_T_SINT] = "sint",
41 [SMP_T_ADDR] = "addr",
42 [SMP_T_IPV4] = "ipv4",
43 [SMP_T_IPV6] = "ipv6",
44 [SMP_T_STR] = "str",
45 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020046 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010047};
48
Willy Tarreau12785782012-04-27 21:37:17 +020049/* static sample used in sample_process() when <p> is NULL */
Willy Tarreaub4a88f02012-04-23 21:35:11 +020050static struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010051
Willy Tarreau12785782012-04-27 21:37:17 +020052/* list head of all known sample fetch keywords */
53static struct sample_fetch_kw_list sample_fetches = {
54 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010055};
56
Willy Tarreau12785782012-04-27 21:37:17 +020057/* list head of all known sample format conversion keywords */
58static struct sample_conv_kw_list sample_convs = {
59 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010060};
61
Willy Tarreau80aca902013-01-07 15:42:20 +010062const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
63 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
64 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
65 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
66 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
67 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
68 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
69 SMP_VAL_FE_LOG_END),
70
71 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
72 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
73 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
74 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
75 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
76 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
77 SMP_VAL_FE_LOG_END),
78
79 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
80 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
81 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
82 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
83 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
84 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
85 SMP_VAL_FE_LOG_END),
86
87 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
88 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
89 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
90 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
91 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
92 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
93 SMP_VAL_FE_LOG_END),
94
95 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
96 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
97 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
98 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
99 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
100 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
101 SMP_VAL_FE_LOG_END),
102
103 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
104 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
105 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
106 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
107 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
108 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
109 SMP_VAL_FE_LOG_END),
110
111 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
112 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
113 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
114 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
115 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
116 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
117 SMP_VAL___________),
118
119 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
120 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
121 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
122 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
123 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
124 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
125 SMP_VAL___________),
126
127 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
128 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
129 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
130 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
131 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
132 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
133 SMP_VAL_FE_LOG_END),
134
135 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
136 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
137 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
138 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
139 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
140 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
141 SMP_VAL___________),
142
143 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
144 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
145 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
146 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
147 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
148 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
149 SMP_VAL_FE_LOG_END),
150
151 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
152 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
153 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
154 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
155 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
156 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
157 SMP_VAL_FE_LOG_END),
158
159 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
160 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
161 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
162 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
163 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
164 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
165 SMP_VAL_FE_LOG_END),
166
167 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
168 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
169 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
170 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
171 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
172 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
173 SMP_VAL_FE_LOG_END),
174
175 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
176 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
177 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
178 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
179 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
180 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
181 SMP_VAL___________),
182
183 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
184 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
185 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
186 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
187 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
188 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
189 SMP_VAL___________),
190
191 [SMP_SRC_HRSHP] = (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_BE_RES_CNT |
195 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
196 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
197 SMP_VAL_FE_LOG_END),
198
199 [SMP_SRC_HRSBO] = (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___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
204 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
205 SMP_VAL___________),
206
207 [SMP_SRC_RQFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
212 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
213 SMP_VAL_FE_LOG_END),
214
215 [SMP_SRC_RSFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
220 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
221 SMP_VAL_FE_LOG_END),
222
223 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
224 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
225 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
226 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
227 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
228 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
229 SMP_VAL_FE_LOG_END),
230
231 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
232 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
233 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
234 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
235 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
236 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
237 SMP_VAL_FE_LOG_END),
238};
239
240static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
241 [SMP_SRC_INTRN] = "internal state",
242 [SMP_SRC_LISTN] = "listener",
243 [SMP_SRC_FTEND] = "frontend",
244 [SMP_SRC_L4CLI] = "client address",
245 [SMP_SRC_L5CLI] = "client-side connection",
246 [SMP_SRC_TRACK] = "track counters",
247 [SMP_SRC_L6REQ] = "request buffer",
248 [SMP_SRC_HRQHV] = "HTTP request headers",
249 [SMP_SRC_HRQHP] = "HTTP request",
250 [SMP_SRC_HRQBO] = "HTTP request body",
251 [SMP_SRC_BKEND] = "backend",
252 [SMP_SRC_SERVR] = "server",
253 [SMP_SRC_L4SRV] = "server address",
254 [SMP_SRC_L5SRV] = "server-side connection",
255 [SMP_SRC_L6RES] = "response buffer",
256 [SMP_SRC_HRSHV] = "HTTP response headers",
257 [SMP_SRC_HRSHP] = "HTTP response",
258 [SMP_SRC_HRSBO] = "HTTP response body",
259 [SMP_SRC_RQFIN] = "request buffer statistics",
260 [SMP_SRC_RSFIN] = "response buffer statistics",
261 [SMP_SRC_TXFIN] = "transaction statistics",
262 [SMP_SRC_SSFIN] = "session statistics",
263};
264
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100265static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
266 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
267 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
268 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
269 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
270 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
271 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
272 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
273 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
274 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
275 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
276 [SMP_CKP_BE_SRV_CON] = "server source selection",
277 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
278 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
279 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
280 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
281 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
282 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
283 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
284 [SMP_CKP_FE_LOG_END] = "logs",
285};
286
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100287/* This function returns the type of the data returned by the sample_expr.
288 * It assumes that the <expr> and all of its converters are properly
289 * initialized.
290 */
291inline
292int smp_expr_output_type(struct sample_expr *expr)
293{
294 struct sample_conv_expr *smp_expr;
295
296 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
297 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
298 return smp_expr->conv->out_type;
299 }
300 return expr->fetch->out_type;
301}
302
303
Willy Tarreau80aca902013-01-07 15:42:20 +0100304/* fill the trash with a comma-delimited list of source names for the <use> bit
305 * field which must be composed of a non-null set of SMP_USE_* flags. The return
306 * value is the pointer to the string in the trash buffer.
307 */
308const char *sample_src_names(unsigned int use)
309{
310 int bit;
311
312 trash.len = 0;
313 trash.str[0] = '\0';
314 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
315 if (!(use & ~((1 << bit) - 1)))
316 break; /* no more bits */
317
318 if (!(use & (1 << bit)))
319 continue; /* bit not set */
320
321 trash.len += snprintf(trash.str + trash.len, trash.size - trash.len, "%s%s",
322 (use & ((1 << bit) - 1)) ? "," : "",
323 fetch_src_names[bit]);
324 }
325 return trash.str;
326}
327
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100328/* return a pointer to the correct sample checkpoint name, or "unknown" when
329 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
330 * if set.
331 */
332const char *sample_ckp_names(unsigned int use)
333{
334 int bit;
335
336 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
337 if (use & (1 << bit))
338 return fetch_ckp_names[bit];
339 return "unknown sample check place, please report this bug";
340}
341
Emeric Brun107ca302010-01-04 16:16:05 +0100342/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100343 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
344 * for next parsing sessions. The fetch keywords capabilities are also computed
345 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100346 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100347void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100348{
Willy Tarreau80aca902013-01-07 15:42:20 +0100349 struct sample_fetch *sf;
350 int bit;
351
352 for (sf = kwl->kw; sf->kw != NULL; sf++) {
353 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
354 if (sf->use & (1 << bit))
355 sf->val |= fetch_cap[bit];
356 }
357 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100358}
359
360/*
Willy Tarreau12785782012-04-27 21:37:17 +0200361 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100362 * parsing sessions.
363 */
Willy Tarreau12785782012-04-27 21:37:17 +0200364void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100365{
Willy Tarreau12785782012-04-27 21:37:17 +0200366 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100367}
368
369/*
Willy Tarreau12785782012-04-27 21:37:17 +0200370 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100371 * string of <len> in buffer <kw>.
372 *
373 */
Willy Tarreau12785782012-04-27 21:37:17 +0200374struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100375{
376 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200377 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100378
Willy Tarreau12785782012-04-27 21:37:17 +0200379 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100380 for (index = 0; kwl->kw[index].kw != NULL; index++) {
381 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
382 kwl->kw[index].kw[len] == '\0')
383 return &kwl->kw[index];
384 }
385 }
386 return NULL;
387}
388
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100389/* This fucntion browse the list of available saple fetch. <current> is
390 * the last used sample fetch. If it is the first call, it must set to NULL.
391 * <idx> is the index of the next sampleèfetch entry. It is used as private
392 * value. It is useles to initiate it.
393 *
394 * It returns always the newt fetch_sample entry, and NULL when the end of
395 * the list is reached.
396 */
397struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
398{
399 struct sample_fetch_kw_list *kwl;
400 struct sample_fetch *base;
401
402 if (!current) {
403 /* Get first kwl entry. */
404 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
405 (*idx) = 0;
406 } else {
407 /* Get kwl corresponding to the curret entry. */
408 base = current + 1 - (*idx);
409 kwl = container_of(base, struct sample_fetch_kw_list, kw);
410 }
411
412 while (1) {
413
414 /* Check if kwl is the last entry. */
415 if (&kwl->list == &sample_fetches.list)
416 return NULL;
417
418 /* idx contain the next keyword. If it is available, return it. */
419 if (kwl->kw[*idx].kw) {
420 (*idx)++;
421 return &kwl->kw[(*idx)-1];
422 }
423
424 /* get next entry in the main list, and return NULL if the end is reached. */
425 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
426
427 /* Set index to 0, ans do one other loop. */
428 (*idx) = 0;
429 }
430}
431
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100432/* This function browses the list of available converters. <current> is
433 * the last used converter. If it is the first call, it must set to NULL.
434 * <idx> is the index of the next converter entry. It is used as private
435 * value. It is useless to initiate it.
436 *
437 * It returns always the next sample_conv entry, and NULL when the end of
438 * the list is reached.
439 */
440struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
441{
442 struct sample_conv_kw_list *kwl;
443 struct sample_conv *base;
444
445 if (!current) {
446 /* Get first kwl entry. */
447 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
448 (*idx) = 0;
449 } else {
450 /* Get kwl corresponding to the curret entry. */
451 base = current + 1 - (*idx);
452 kwl = container_of(base, struct sample_conv_kw_list, kw);
453 }
454
455 while (1) {
456 /* Check if kwl is the last entry. */
457 if (&kwl->list == &sample_convs.list)
458 return NULL;
459
460 /* idx contain the next keyword. If it is available, return it. */
461 if (kwl->kw[*idx].kw) {
462 (*idx)++;
463 return &kwl->kw[(*idx)-1];
464 }
465
466 /* get next entry in the main list, and return NULL if the end is reached. */
467 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
468
469 /* Set index to 0, ans do one other loop. */
470 (*idx) = 0;
471 }
472}
473
Emeric Brun107ca302010-01-04 16:16:05 +0100474/*
Willy Tarreau12785782012-04-27 21:37:17 +0200475 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100476 * string of <len> in buffer <kw>.
477 *
478 */
Willy Tarreau12785782012-04-27 21:37:17 +0200479struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100480{
481 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200482 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100483
Willy Tarreau12785782012-04-27 21:37:17 +0200484 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100485 for (index = 0; kwl->kw[index].kw != NULL; index++) {
486 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
487 kwl->kw[index].kw[len] == '\0')
488 return &kwl->kw[index];
489 }
490 }
491 return NULL;
492}
493
Emeric Brun107ca302010-01-04 16:16:05 +0100494/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200495/* Sample casts functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200496/* Note: these functions do *NOT* set the output type on the */
497/* sample, the caller is responsible for doing this on return. */
Emeric Brun107ca302010-01-04 16:16:05 +0100498/******************************************************************/
499
Willy Tarreau342acb42012-04-23 22:03:39 +0200500static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100501{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200502 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200503 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100504 return 1;
505}
506
Willy Tarreau342acb42012-04-23 22:03:39 +0200507static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100508{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100509 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100510
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200511 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->str, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100512 return 0;
513
514 trash->len = strlen(trash->str);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200515 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200516 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100517 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100518
519 return 1;
520}
521
Willy Tarreau342acb42012-04-23 22:03:39 +0200522static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100523{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200524 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200525 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100526 return 1;
527}
528
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200529static int c_ipv62ip(struct sample *smp)
530{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200531 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200532 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200533 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200534 return 1;
535}
536
Willy Tarreau342acb42012-04-23 22:03:39 +0200537static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100538{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100539 struct chunk *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100540
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200541 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->str, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100542 return 0;
543
544 trash->len = strlen(trash->str);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200545 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200546 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100547 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100548 return 1;
549}
550
551/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200552static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100553{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200554 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100555}
556*/
557
Willy Tarreau342acb42012-04-23 22:03:39 +0200558static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100559{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200560 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200561 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100562 return 1;
563}
564
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200565static int c_int2ipv6(struct sample *smp)
566{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200567 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
568 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200569 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200570 return 1;
571}
572
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100573static int c_str2addr(struct sample *smp)
574{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200575 if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv4)) {
576 if (!buf2ip6(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100577 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200578 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100579 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100580 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100581 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200582 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100583 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100584 return 1;
585}
586
Willy Tarreau342acb42012-04-23 22:03:39 +0200587static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100588{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200589 if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100590 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200591 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100592 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100593 return 1;
594}
595
Willy Tarreau342acb42012-04-23 22:03:39 +0200596static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100597{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200598 if (!buf2ip6(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100599 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200600 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100601 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100602 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100603}
604
Emeric Brun4b9e8022014-11-03 18:17:10 +0100605/*
606 * The NULL char always enforces the end of string if it is met.
607 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100608 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200609static int c_bin2str(struct sample *smp)
610{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100611 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200612
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200613 for (i = 0; i < smp->data.u.str.len; i++) {
614 if (!smp->data.u.str.str[i]) {
615 smp->data.u.str.len = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100616 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100617 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200618 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200619 return 1;
620}
621
Willy Tarreau342acb42012-04-23 22:03:39 +0200622static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100623{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100624 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100625 char *pos;
626
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200627 pos = lltoa_r(smp->data.u.sint, trash->str, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100628 if (!pos)
629 return 0;
630
Emeric Brun485479d2010-09-23 18:02:19 +0200631 trash->size = trash->size - (pos - trash->str);
Emeric Brun107ca302010-01-04 16:16:05 +0100632 trash->str = pos;
633 trash->len = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200634 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200635 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100636 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100637 return 1;
638}
639
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100640/* This function duplicates data and removes the flag "const". */
641int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200642{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100643 struct chunk *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200644
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100645 /* If the const flag is not set, we don't need to duplicate the
646 * pattern as it can be modified in place.
647 */
648 if (!(smp->flags & SMP_F_CONST))
649 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100650
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200651 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100652 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100653 case SMP_T_SINT:
654 case SMP_T_ADDR:
655 case SMP_T_IPV4:
656 case SMP_T_IPV6:
657 /* These type are not const. */
658 break;
659 case SMP_T_STR:
660 case SMP_T_BIN:
661 /* Duplicate data. */
662 trash = get_trash_chunk();
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200663 trash->len = smp->data.u.str.len < trash->size ? smp->data.u.str.len : trash->size;
664 memcpy(trash->str, smp->data.u.str.str, trash->len);
665 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100666 break;
667 default:
668 /* Other cases are unexpected. */
669 return 0;
670 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100671
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100672 /* remove const flag */
673 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200674 return 1;
675}
676
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100677int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100678{
679 return 1;
680}
681
Willy Tarreau342acb42012-04-23 22:03:39 +0200682static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100683{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200684 const char *str;
685 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100686
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200687 if (smp->data.u.str.len == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100688 return 0;
689
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200690 str = smp->data.u.str.str;
691 end = smp->data.u.str.str + smp->data.u.str.len;
Emeric Brun107ca302010-01-04 16:16:05 +0100692
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200693 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200694 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100695 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100696 return 1;
697}
698
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100699static int c_str2meth(struct sample *smp)
700{
701 enum http_meth_t meth;
702 int len;
703
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200704 meth = find_http_meth(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100705 if (meth == HTTP_METH_OTHER) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200706 len = smp->data.u.str.len;
707 smp->data.u.meth.str.str = smp->data.u.str.str;
708 smp->data.u.meth.str.len = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100709 }
710 else
711 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200712 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200713 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100714 return 1;
715}
716
717static int c_meth2str(struct sample *smp)
718{
719 int len;
720 enum http_meth_t meth;
721
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200722 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100723 /* The method is unknown. Copy the original pointer. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200724 len = smp->data.u.meth.str.len;
725 smp->data.u.str.str = smp->data.u.meth.str.str;
726 smp->data.u.str.len = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200727 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100728 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200729 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100730 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200731 meth = smp->data.u.meth.meth;
732 smp->data.u.str.str = http_known_methods[meth].name;
733 smp->data.u.str.len = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100734 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200735 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100736 }
737 else {
738 /* Unknown method */
739 return 0;
740 }
741 return 1;
742}
743
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200744static int c_addr2bin(struct sample *smp)
745{
746 struct chunk *chk = get_trash_chunk();
747
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200748 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200749 chk->len = 4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200750 memcpy(chk->str, &smp->data.u.ipv4, chk->len);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200751 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200752 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200753 chk->len = 16;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200754 memcpy(chk->str, &smp->data.u.ipv6, chk->len);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200755 }
756 else
757 return 0;
758
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200759 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200760 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200761 return 1;
762}
763
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200764static int c_int2bin(struct sample *smp)
765{
766 struct chunk *chk = get_trash_chunk();
767
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200768 *(unsigned long long int *)chk->str = htonll(smp->data.u.sint);
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200769 chk->len = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200770
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200771 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200772 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200773 return 1;
774}
775
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200776
Emeric Brun107ca302010-01-04 16:16:05 +0100777/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200778/* Sample casts matrix: */
779/* sample_casts[from type][to type] */
780/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100781/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100782
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100783sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200784/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
785/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
786/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200787/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, c_int2ipv6, c_int2str, c_int2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200788/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
789/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200790/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200791/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
792/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
793/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200794};
Emeric Brun107ca302010-01-04 16:16:05 +0100795
Emeric Brun107ca302010-01-04 16:16:05 +0100796/*
Willy Tarreau12785782012-04-27 21:37:17 +0200797 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100798 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200799 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200800 * The caller must have set al->ctx.
Emeric Brun107ca302010-01-04 16:16:05 +0100801 */
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100802struct 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 +0100803{
Willy Tarreau833cc792013-07-24 15:34:19 +0200804 const char *begw; /* beginning of word */
805 const char *endw; /* end of word */
806 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200807 struct sample_expr *expr;
808 struct sample_fetch *fetch;
809 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100810 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200811 char *fkw = NULL;
812 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100813 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100814
Willy Tarreau833cc792013-07-24 15:34:19 +0200815 begw = str[*idx];
816 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
817
818 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100819 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100820 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200821 }
Emeric Brun107ca302010-01-04 16:16:05 +0100822
Willy Tarreau833cc792013-07-24 15:34:19 +0200823 /* keep a copy of the current fetch keyword for error reporting */
824 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100825
Willy Tarreau833cc792013-07-24 15:34:19 +0200826 fetch = find_sample_fetch(begw, endw - begw);
827 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100828 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100829 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200830 }
Emeric Brun107ca302010-01-04 16:16:05 +0100831
Willy Tarreau833cc792013-07-24 15:34:19 +0200832 endt = endw;
833 if (*endt == '(') {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100834 /* look for the end of this term and skip the opening parenthesis */
835 endt = ++endw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200836 while (*endt && *endt != ')')
837 endt++;
838 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100839 memprintf(err_msg, "missing closing ')' after arguments to fetch keyword '%s'", fkw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200840 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200841 }
Emeric Brun485479d2010-09-23 18:02:19 +0200842 }
Emeric Brun107ca302010-01-04 16:16:05 +0100843
Willy Tarreau833cc792013-07-24 15:34:19 +0200844 /* At this point, we have :
845 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100846 * - endw : end of the keyword, first character not part of keyword
847 * nor the opening parenthesis (so first character of args
848 * if present).
Willy Tarreau833cc792013-07-24 15:34:19 +0200849 * - endt : end of the term (=endw or last parenthesis if args are present)
850 */
851
852 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100853 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100854 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200855 }
Emeric Brun107ca302010-01-04 16:16:05 +0100856 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200857
Willy Tarreau12785782012-04-27 21:37:17 +0200858 expr = calloc(1, sizeof(struct sample_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200859 if (!expr)
860 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100861
862 LIST_INIT(&(expr->conv_exprs));
863 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200864 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100865
Willy Tarreau689a1df2013-12-13 00:40:11 +0100866 /* Note that we call the argument parser even with an empty string,
867 * this allows it to automatically create entries for mandatory
868 * implicit arguments (eg: local proxy name).
869 */
870 al->kw = expr->fetch->kw;
871 al->conv = NULL;
872 if (make_arg_list(endw, endt - endw, fetch->arg_mask, &expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
873 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
874 goto out_error;
875 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200876
Willy Tarreau689a1df2013-12-13 00:40:11 +0100877 if (!expr->arg_p) {
878 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200879 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100880 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
881 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200882 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100883 }
884
Willy Tarreau833cc792013-07-24 15:34:19 +0200885 /* Now process the converters if any. We have two supported syntaxes
886 * for the converters, which can be combined :
887 * - comma-delimited list of converters just after the keyword and args ;
888 * - one converter per keyword
889 * The combination allows to have each keyword being a comma-delimited
890 * series of converters.
891 *
892 * We want to process the former first, then the latter. For this we start
893 * from the beginning of the supposed place in the exiting conv chain, which
894 * starts at the last comma (endt).
895 */
896
897 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200898 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100899
Willy Tarreau833cc792013-07-24 15:34:19 +0200900 if (*endt == ')') /* skip last closing parenthesis */
901 endt++;
Emeric Brun107ca302010-01-04 16:16:05 +0100902
Willy Tarreau833cc792013-07-24 15:34:19 +0200903 if (*endt && *endt != ',') {
904 if (ckw)
Willy Tarreau975c1782013-12-12 23:16:54 +0100905 memprintf(err_msg, "missing comma after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200906 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100907 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100908 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200909 }
Emeric Brun107ca302010-01-04 16:16:05 +0100910
Willy Tarreau833cc792013-07-24 15:34:19 +0200911 while (*endt == ',') /* then trailing commas */
912 endt++;
913
914 begw = endt; /* start of conv keyword */
915
916 if (!*begw) {
917 /* none ? skip to next string */
918 (*idx)++;
919 begw = str[*idx];
920 if (!begw || !*begw)
921 break;
922 }
923
924 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
925
926 free(ckw);
927 ckw = my_strndup(begw, endw - begw);
928
929 conv = find_sample_conv(begw, endw - begw);
930 if (!conv) {
931 /* we found an isolated keyword that we don't know, it's not ours */
932 if (begw == str[*idx])
933 break;
Willy Tarreau975c1782013-12-12 23:16:54 +0100934 memprintf(err_msg, "unknown conv method '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200935 goto out_error;
936 }
Emeric Brun107ca302010-01-04 16:16:05 +0100937
Willy Tarreau833cc792013-07-24 15:34:19 +0200938 endt = endw;
939 if (*endt == '(') {
940 /* look for the end of this term */
941 while (*endt && *endt != ')')
942 endt++;
943 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100944 memprintf(err_msg, "syntax error: missing ')' after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200945 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200946 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200947 }
948
949 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100950 memprintf(err_msg, "returns type of conv method '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100951 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200952 }
Emeric Brun107ca302010-01-04 16:16:05 +0100953
954 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200955 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100956 memprintf(err_msg, "conv method '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100957 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200958 }
Emeric Brun107ca302010-01-04 16:16:05 +0100959
960 prev_type = conv->out_type;
Willy Tarreau12785782012-04-27 21:37:17 +0200961 conv_expr = calloc(1, sizeof(struct sample_conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200962 if (!conv_expr)
963 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100964
965 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
966 conv_expr->conv = conv;
967
Willy Tarreau833cc792013-07-24 15:34:19 +0200968 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200969 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200970
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200971 if (!conv->arg_mask) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100972 memprintf(err_msg, "conv method '%s' does not support any args", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200973 goto out_error;
974 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100975
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200976 al->kw = expr->fetch->kw;
977 al->conv = conv_expr->conv->kw;
Willy Tarreau975c1782013-12-12 23:16:54 +0100978 if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
979 memprintf(err_msg, "invalid arg %d in conv method '%s' : %s", err_arg+1, ckw, *err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200980 goto out_error;
981 }
982
Willy Tarreau2e845be2012-10-19 19:49:09 +0200983 if (!conv_expr->arg_p)
984 conv_expr->arg_p = empty_arg_list;
985
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100986 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100987 memprintf(err_msg, "invalid args in conv method '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200988 goto out_error;
989 }
990 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200991 else if (ARGM(conv->arg_mask)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100992 memprintf(err_msg, "missing args for conv method '%s'", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200993 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100994 }
995 }
Emeric Brun485479d2010-09-23 18:02:19 +0200996
Willy Tarreau833cc792013-07-24 15:34:19 +0200997 out:
998 free(fkw);
999 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001000 return expr;
1001
1002out_error:
Willy Tarreau12785782012-04-27 21:37:17 +02001003 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +02001004 expr = NULL;
1005 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001006}
1007
1008/*
Willy Tarreau12785782012-04-27 21:37:17 +02001009 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001010 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001011 * Returns a pointer on a typed sample structure containing the result or NULL if
1012 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001013 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001014 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001015 *
1016 * Note: the fetch functions are required to properly set the return type. The
1017 * conversion functions must do so too. However the cast functions do not need
1018 * to since they're made to cast mutiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001019 *
1020 * The caller may indicate in <opt> if it considers the result final or not.
1021 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1022 * if the result is stable or not, according to the following table :
1023 *
1024 * return MAY_CHANGE FINAL Meaning for the sample
1025 * NULL 0 * Not present and will never be (eg: header)
1026 * NULL 1 0 Not present yet, could change (eg: POST param)
1027 * NULL 1 1 Not present yet, will not change anymore
1028 * smp 0 * Present and will not change (eg: header)
1029 * smp 1 0 Present, may change (eg: request length)
1030 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001031 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001032struct sample *sample_process(struct proxy *px, struct session *sess,
1033 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001034 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001035{
Willy Tarreau12785782012-04-27 21:37:17 +02001036 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001037
Willy Tarreau18387e22013-07-25 12:02:38 +02001038 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001039 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001040 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001041 }
Emeric Brun107ca302010-01-04 16:16:05 +01001042
Thierry FOURNIER6879ad32015-05-11 11:54:58 +02001043 p->px = px;
1044 p->sess = sess;
1045 p->strm = strm;
Thierry FOURNIER1d33b882015-05-11 15:25:29 +02001046 p->opt = opt;
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001047 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001048 return NULL;
1049
Emeric Brun107ca302010-01-04 16:16:05 +01001050 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001051 /* we want to ensure that p->type can be casted into
1052 * conv_expr->conv->in_type. We have 3 possibilities :
1053 * - NULL => not castable.
1054 * - c_none => nothing to do (let's optimize it)
1055 * - other => apply cast and prepare to fail
1056 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001057 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001058 return NULL;
1059
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001060 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1061 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001062 return NULL;
1063
Willy Tarreau12e50112012-04-25 17:21:49 +02001064 /* OK cast succeeded */
1065
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001066 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001067 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001068 }
1069 return p;
1070}
1071
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001072/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001073 * Resolve all remaining arguments in proxy <p>. Returns the number of
1074 * errors or 0 if everything is fine.
1075 */
1076int smp_resolve_args(struct proxy *p)
1077{
1078 struct arg_list *cur, *bak;
1079 const char *ctx, *where;
1080 const char *conv_ctx, *conv_pre, *conv_pos;
1081 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001082 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001083 struct arg *arg;
1084 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001085 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001086
1087 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1088 struct proxy *px;
1089 struct server *srv;
1090 char *pname, *sname;
Willy Tarreau46947782015-01-19 19:00:58 +01001091 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001092
1093 arg = cur->arg;
1094
1095 /* prepare output messages */
1096 conv_pre = conv_pos = conv_ctx = "";
1097 if (cur->conv) {
1098 conv_ctx = cur->conv;
1099 conv_pre = "conversion keyword '";
1100 conv_pos = "' for ";
1101 }
1102
1103 where = "in";
1104 ctx = "sample fetch keyword";
1105 switch (cur->ctx) {
Willy Tarreau46947782015-01-19 19:00:58 +01001106 case ARGC_STK: where = "in stick rule in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001107 case ARGC_TRK: where = "in tracking rule in"; break;
1108 case ARGC_LOG: where = "in log-format string in"; break;
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +01001109 case ARGC_HRQ: where = "in http-request header format string in"; break;
1110 case ARGC_HRS: where = "in http-response header format string in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001111 case ARGC_UIF: where = "in unique-id-format string in"; break;
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +01001112 case ARGC_RDR: where = "in redirect format string in"; break;
Willy Tarreau3a4ac422014-06-13 16:17:14 +02001113 case ARGC_CAP: where = "in capture rule in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001114 case ARGC_ACL: ctx = "ACL keyword"; break;
Willy Tarreau28d976d2015-07-09 11:39:33 +02001115 case ARGC_SRV: where = "in server directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001116 }
1117
1118 /* set a few default settings */
1119 px = p;
1120 pname = p->id;
1121
1122 switch (arg->type) {
1123 case ARGT_SRV:
1124 if (!arg->data.str.len) {
1125 Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1126 cur->file, cur->line,
1127 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1128 cfgerr++;
1129 continue;
1130 }
1131
1132 /* we support two formats : "bck/srv" and "srv" */
1133 sname = strrchr(arg->data.str.str, '/');
1134
1135 if (sname) {
1136 *sname++ = '\0';
1137 pname = arg->data.str.str;
1138
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001139 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001140 if (!px) {
1141 Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1142 cur->file, cur->line, pname,
1143 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1144 cfgerr++;
1145 break;
1146 }
1147 }
1148 else
1149 sname = arg->data.str.str;
1150
1151 srv = findserver(px, sname);
1152 if (!srv) {
1153 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",
1154 cur->file, cur->line, sname, pname,
1155 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1156 cfgerr++;
1157 break;
1158 }
1159
1160 free(arg->data.str.str);
1161 arg->data.str.str = NULL;
1162 arg->unresolved = 0;
1163 arg->data.srv = srv;
1164 break;
1165
1166 case ARGT_FE:
1167 if (arg->data.str.len) {
1168 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001169 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001170 }
1171
1172 if (!px) {
1173 Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1174 cur->file, cur->line, pname,
1175 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1176 cfgerr++;
1177 break;
1178 }
1179
1180 if (!(px->cap & PR_CAP_FE)) {
1181 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1182 cur->file, cur->line, pname,
1183 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1184 cfgerr++;
1185 break;
1186 }
1187
1188 free(arg->data.str.str);
1189 arg->data.str.str = NULL;
1190 arg->unresolved = 0;
1191 arg->data.prx = px;
1192 break;
1193
1194 case ARGT_BE:
1195 if (arg->data.str.len) {
1196 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001197 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001198 }
1199
1200 if (!px) {
1201 Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1202 cur->file, cur->line, pname,
1203 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1204 cfgerr++;
1205 break;
1206 }
1207
1208 if (!(px->cap & PR_CAP_BE)) {
1209 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1210 cur->file, cur->line, pname,
1211 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1212 cfgerr++;
1213 break;
1214 }
1215
1216 free(arg->data.str.str);
1217 arg->data.str.str = NULL;
1218 arg->unresolved = 0;
1219 arg->data.prx = px;
1220 break;
1221
1222 case ARGT_TAB:
1223 if (arg->data.str.len) {
1224 pname = arg->data.str.str;
Willy Tarreaue2dc1fa2015-05-26 12:08:07 +02001225 px = proxy_tbl_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001226 }
1227
1228 if (!px) {
1229 Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1230 cur->file, cur->line, pname,
1231 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1232 cfgerr++;
1233 break;
1234 }
1235
1236 if (!px->table.size) {
1237 Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1238 cur->file, cur->line, pname,
1239 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1240 cfgerr++;
1241 break;
1242 }
1243
1244 free(arg->data.str.str);
1245 arg->data.str.str = NULL;
1246 arg->unresolved = 0;
1247 arg->data.prx = px;
1248 break;
1249
1250 case ARGT_USR:
1251 if (!arg->data.str.len) {
1252 Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1253 cur->file, cur->line,
1254 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1255 cfgerr++;
1256 break;
1257 }
1258
1259 if (p->uri_auth && p->uri_auth->userlist &&
1260 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1261 ul = p->uri_auth->userlist;
1262 else
1263 ul = auth_find_userlist(arg->data.str.str);
1264
1265 if (!ul) {
1266 Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1267 cur->file, cur->line, arg->data.str.str,
1268 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1269 cfgerr++;
1270 break;
1271 }
1272
1273 free(arg->data.str.str);
1274 arg->data.str.str = NULL;
1275 arg->unresolved = 0;
1276 arg->data.usr = ul;
1277 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001278
1279 case ARGT_REG:
1280 if (!arg->data.str.len) {
1281 Alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1282 cur->file, cur->line,
1283 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1284 cfgerr++;
1285 continue;
1286 }
1287
1288 reg = calloc(1, sizeof(*reg));
1289 if (!reg) {
1290 Alert("parsing [%s:%d] : not enough memory to build regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1291 cur->file, cur->line,
1292 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1293 cfgerr++;
1294 continue;
1295 }
1296
1297 rflags = 0;
1298 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1299 err = NULL;
1300
Willy Tarreaud817e462015-01-23 20:23:17 +01001301 if (!regex_comp(arg->data.str.str, reg, !(rflags & REG_ICASE), 1 /* capture substr */, &err)) {
Willy Tarreau46947782015-01-19 19:00:58 +01001302 Alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1303 cur->file, cur->line,
1304 arg->data.str.str,
1305 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
1306 cfgerr++;
1307 continue;
1308 }
1309
1310 free(arg->data.str.str);
1311 arg->data.str.str = NULL;
1312 arg->unresolved = 0;
1313 arg->data.reg = reg;
1314 break;
1315
1316
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001317 }
1318
1319 LIST_DEL(&cur->list);
1320 free(cur);
1321 } /* end of args processing */
1322
1323 return cfgerr;
1324}
1325
1326/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001327 * Process a fetch + format conversion as defined by the sample expression
1328 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001329 * not explicitly set to <smp_type>, but shall be compatible with it as
1330 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1331 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001332 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1333 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1334 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1335 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001336 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1337 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1338 * still hope to get it after waiting longer, and is not converted to string.
1339 * The possible output combinations are the following :
1340 *
1341 * return MAY_CHANGE FINAL Meaning for the sample
1342 * NULL * * Not present and will never be (eg: header)
1343 * smp 0 * Final value converted (eg: header)
1344 * smp 1 0 Not present yet, may appear later (eg: header)
1345 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001346 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001347struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001348 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001349 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001350{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001351 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001352
Willy Tarreau6c616e02014-06-25 16:56:41 +02001353 memset(smp, 0, sizeof(*smp));
1354
Willy Tarreau192252e2015-04-04 01:47:55 +02001355 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001356 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1357 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001358 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001359 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001360
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001361 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001362 return NULL;
1363
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001364 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001365 return NULL;
1366
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001367 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001368 return smp;
1369}
1370
Emeric Brun107ca302010-01-04 16:16:05 +01001371/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001372/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001373/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001374/*****************************************************************/
1375
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001376#ifdef DEBUG_EXPR
1377static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1378{
1379 int i;
1380 struct sample tmp;
1381
1382 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001383 fprintf(stderr, "[debug converter] type: %s ", smp_to_type[smp->data.type]);
1384 if (!sample_casts[smp->data.type][SMP_T_STR]) {
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001385 fprintf(stderr, "(undisplayable)");
1386 } else {
1387
1388 /* Copy sample fetch. This put the sample as const, the
1389 * cast will copy data if a transformation is required.
1390 */
1391 memcpy(&tmp, smp, sizeof(struct sample));
1392 tmp.flags = SMP_F_CONST;
1393
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001394 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001395 fprintf(stderr, "(undisplayable)");
1396
1397 else {
1398 /* Display the displayable chars*. */
1399 fprintf(stderr, "<");
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001400 for (i = 0; i < tmp.data.u.str.len; i++) {
1401 if (isprint(tmp.data.u.str.str[i]))
1402 fputc(tmp.data.u.str.str[i], stderr);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001403 else
1404 fputc('.', stderr);
1405 }
1406 }
1407 fprintf(stderr, ">\n");
1408 }
1409 }
1410 return 1;
1411}
1412#endif
1413
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001414static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001415{
1416 struct chunk *trash = get_trash_chunk();
1417 int b64_len;
1418
1419 trash->len = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001420 b64_len = a2base64(smp->data.u.str.str, smp->data.u.str.len, trash->str, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001421 if (b64_len < 0)
1422 return 0;
1423
1424 trash->len = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001425 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001426 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001427 smp->flags &= ~SMP_F_CONST;
1428 return 1;
1429}
1430
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001431static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001432{
1433 struct chunk *trash = get_trash_chunk();
1434 unsigned char c;
1435 int ptr = 0;
1436
1437 trash->len = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001438 while (ptr < smp->data.u.str.len && trash->len <= trash->size - 2) {
1439 c = smp->data.u.str.str[ptr++];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001440 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
1441 trash->str[trash->len++] = hextab[c & 0xF];
1442 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001443 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001444 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001445 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001446 return 1;
1447}
1448
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001449/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001450static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001451{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001452 smp->data.u.sint = hash_djb2(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001453 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001454 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001455 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001456 return 1;
1457}
1458
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001459static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001460{
1461 int i;
1462
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001463 if (!smp_dup(smp))
1464 return 0;
1465
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001466 if (!smp->data.u.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001467 return 0;
1468
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001469 for (i = 0; i < smp->data.u.str.len; i++) {
1470 if ((smp->data.u.str.str[i] >= 'A') && (smp->data.u.str.str[i] <= 'Z'))
1471 smp->data.u.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001472 }
1473 return 1;
1474}
1475
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001476static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001477{
1478 int i;
1479
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001480 if (!smp_dup(smp))
1481 return 0;
1482
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001483 if (!smp->data.u.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001484 return 0;
1485
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001486 for (i = 0; i < smp->data.u.str.len; i++) {
1487 if ((smp->data.u.str.str[i] >= 'a') && (smp->data.u.str.str[i] <= 'z'))
1488 smp->data.u.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001489 }
1490 return 1;
1491}
1492
Willy Tarreauf9954102012-04-20 14:03:29 +02001493/* takes the netmask in arg_p */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001494static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001495{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001496 smp->data.u.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001497 smp->data.type = SMP_T_IPV4;
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001498 return 1;
1499}
1500
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001501/* takes an UINT value on input supposed to represent the time since EPOCH,
1502 * adds an optional offset found in args[1] and emits a string representing
1503 * the local time in the format specified in args[1] using strftime().
1504 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001505static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001506{
1507 struct chunk *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001508 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001509 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001510 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001511
1512 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001513 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001514 curr_date += args[1].data.sint;
1515
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001516 tm = localtime(&curr_date);
1517 if (!tm)
1518 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001519 temp = get_trash_chunk();
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001520 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001521 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001522 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001523 return 1;
1524}
1525
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001526/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001527static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001528{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001529 smp->data.u.sint = hash_sdbm(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001530 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001531 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001532 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001533 return 1;
1534}
1535
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001536/* takes an UINT value on input supposed to represent the time since EPOCH,
1537 * adds an optional offset found in args[1] and emits a string representing
1538 * the UTC date in the format specified in args[1] using strftime().
1539 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001540static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001541{
1542 struct chunk *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001543 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001544 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001545 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001546
1547 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001548 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001549 curr_date += args[1].data.sint;
1550
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001551 tm = gmtime(&curr_date);
1552 if (!tm)
1553 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001554 temp = get_trash_chunk();
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001555 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001556 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001557 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001558 return 1;
1559}
1560
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001561/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001562static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001563{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001564 smp->data.u.sint = hash_wt6(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001565 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001566 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001567 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001568 return 1;
1569}
1570
Willy Tarreau80599772015-01-20 19:35:24 +01001571/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001572static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01001573{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001574 smp->data.u.sint = hash_crc32(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001575 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001576 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001577 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01001578 return 1;
1579}
1580
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001581/* This function escape special json characters. The returned string can be
1582 * safely set between two '"' and used as json string. The json string is
1583 * defined like this:
1584 *
1585 * any Unicode character except '"' or '\' or control character
1586 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
1587 *
1588 * The enum input_type contain all the allowed mode for decoding the input
1589 * string.
1590 */
1591enum input_type {
1592 IT_ASCII = 0,
1593 IT_UTF8,
1594 IT_UTF8S,
1595 IT_UTF8P,
1596 IT_UTF8PS,
1597};
1598static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
1599 const char *file, int line, char **err)
1600{
1601 if (!arg) {
1602 memprintf(err, "Unexpected empty arg list");
1603 return 0;
1604 }
1605
1606 if (arg->type != ARGT_STR) {
1607 memprintf(err, "Unexpected arg type");
1608 return 0;
1609 }
1610
1611 if (strcmp(arg->data.str.str, "") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001612 arg->type = ARGT_SINT;
1613 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001614 return 1;
1615 }
1616
1617 else if (strcmp(arg->data.str.str, "ascii") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001618 arg->type = ARGT_SINT;
1619 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001620 return 1;
1621 }
1622
1623 else if (strcmp(arg->data.str.str, "utf8") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001624 arg->type = ARGT_SINT;
1625 arg->data.sint = IT_UTF8;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001626 return 1;
1627 }
1628
1629 else if (strcmp(arg->data.str.str, "utf8s") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001630 arg->type = ARGT_SINT;
1631 arg->data.sint = IT_UTF8S;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001632 return 1;
1633 }
1634
1635 else if (strcmp(arg->data.str.str, "utf8p") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001636 arg->type = ARGT_SINT;
1637 arg->data.sint = IT_UTF8P;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001638 return 1;
1639 }
1640
1641 else if (strcmp(arg->data.str.str, "utf8ps") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001642 arg->type = ARGT_SINT;
1643 arg->data.sint = IT_UTF8PS;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001644 return 1;
1645 }
1646
1647 memprintf(err, "Unexpected input code type at file '%s', line %d. "
1648 "Allowed value are 'ascii', 'utf8', 'utf8p' and 'utf8pp'", file, line);
1649 return 0;
1650}
1651
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001652static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001653{
1654 struct chunk *temp;
1655 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
1656 const char *str;
1657 int len;
1658 enum input_type input_type = IT_ASCII;
1659 unsigned int c;
1660 unsigned int ret;
1661 char *p;
1662
1663 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001664 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001665
1666 temp = get_trash_chunk();
1667 temp->len = 0;
1668
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001669 p = smp->data.u.str.str;
1670 while (p < smp->data.u.str.str + smp->data.u.str.len) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001671
1672 if (input_type == IT_ASCII) {
1673 /* Read input as ASCII. */
1674 c = *(unsigned char *)p;
1675 p++;
1676 }
1677 else {
1678 /* Read input as UTF8. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001679 ret = utf8_next(p, smp->data.u.str.len - ( p - smp->data.u.str.str ), &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001680 p += utf8_return_length(ret);
1681
1682 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
1683 return 0;
1684 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
1685 continue;
1686 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1687 return 0;
1688 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1689 continue;
1690
1691 /* Check too big values. */
1692 if ((unsigned int)c > 0xffff) {
1693 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
1694 return 0;
1695 continue;
1696 }
1697 }
1698
1699 /* Convert character. */
1700 if (c == '"') {
1701 len = 2;
1702 str = "\\\"";
1703 }
1704 else if (c == '\\') {
1705 len = 2;
1706 str = "\\\\";
1707 }
1708 else if (c == '/') {
1709 len = 2;
1710 str = "\\/";
1711 }
1712 else if (c == '\b') {
1713 len = 2;
1714 str = "\\b";
1715 }
1716 else if (c == '\f') {
1717 len = 2;
1718 str = "\\f";
1719 }
1720 else if (c == '\r') {
1721 len = 2;
1722 str = "\\r";
1723 }
1724 else if (c == '\n') {
1725 len = 2;
1726 str = "\\n";
1727 }
1728 else if (c == '\t') {
1729 len = 2;
1730 str = "\\t";
1731 }
1732 else if (c > 0xff || !isprint(c)) {
1733 /* isprint generate a segfault if c is too big. The man says that
1734 * c must have the value of an unsigned char or EOF.
1735 */
1736 len = 6;
1737 _str[0] = '\\';
1738 _str[1] = 'u';
1739 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
1740 str = _str;
1741 }
1742 else {
1743 len = 1;
1744 str = (char *)&c;
1745 }
1746
1747 /* Check length */
1748 if (temp->len + len > temp->size)
1749 return 0;
1750
1751 /* Copy string. */
1752 memcpy(temp->str + temp->len, str, len);
1753 temp->len += len;
1754 }
1755
1756 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001757 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001758 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001759
1760 return 1;
1761}
1762
Emeric Brun54c4ac82014-11-03 15:32:43 +01001763/* This sample function is designed to extract some bytes from an input buffer.
1764 * First arg is the offset.
1765 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001766static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01001767{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001768 if (smp->data.u.str.len <= arg_p[0].data.sint) {
1769 smp->data.u.str.len = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001770 return 1;
1771 }
1772
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001773 if (smp->data.u.str.size)
1774 smp->data.u.str.size -= arg_p[0].data.sint;
1775 smp->data.u.str.len -= arg_p[0].data.sint;
1776 smp->data.u.str.str += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001777
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001778 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.len))
1779 smp->data.u.str.len = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001780
1781 return 1;
1782}
1783
Emeric Brunf399b0d2014-11-03 17:07:03 +01001784static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
1785 const char *file, int line, char **err)
1786{
1787 struct arg *arg = args;
1788
1789 if (!arg) {
1790 memprintf(err, "Unexpected empty arg list");
1791 return 0;
1792 }
1793
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001794 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001795 memprintf(err, "Unexpected arg type");
1796 return 0;
1797 }
1798
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001799 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001800 memprintf(err, "Unexpected value 0 for index");
1801 return 0;
1802 }
1803
1804 arg++;
1805
1806 if (arg->type != ARGT_STR) {
1807 memprintf(err, "Unexpected arg type");
1808 return 0;
1809 }
1810
1811 if (!arg->data.str.len) {
1812 memprintf(err, "Empty separators list");
1813 return 0;
1814 }
1815
1816 return 1;
1817}
1818
1819/* This sample function is designed to a return selected part of a string (field).
1820 * First arg is the index of the field (start at 1)
1821 * Second arg is a char list of separators (type string)
1822 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001823static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001824{
1825 unsigned int field;
1826 char *start, *end;
1827 int i;
1828
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001829 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001830 return 0;
1831
1832 field = 1;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001833 end = start = smp->data.u.str.str;
1834 while (end - smp->data.u.str.str < smp->data.u.str.len) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001835
1836 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
1837 if (*end == arg_p[1].data.str.str[i]) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001838 if (field == arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001839 goto found;
1840 start = end+1;
1841 field++;
1842 break;
1843 }
1844 }
1845 end++;
1846 }
1847
1848 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001849 if (field != arg_p[0].data.sint) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001850 smp->data.u.str.len = 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001851 return 1;
1852 }
1853found:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001854 smp->data.u.str.len = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001855 /* If ret string is len 0, no need to
1856 change pointers or to update size */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001857 if (!smp->data.u.str.len)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001858 return 1;
1859
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001860 smp->data.u.str.str = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001861
1862 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001863 Note: smp->data.u.str.size cannot be set to 0 */
1864 if (smp->data.u.str.size)
1865 smp->data.u.str.size -= start - smp->data.u.str.str;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001866
1867 return 1;
1868}
1869
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001870/* This sample function is designed to return a word from a string.
1871 * First arg is the index of the word (start at 1)
1872 * Second arg is a char list of words separators (type string)
1873 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001874static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001875{
1876 unsigned int word;
1877 char *start, *end;
1878 int i, issep, inword;
1879
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001880 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001881 return 0;
1882
1883 word = 0;
1884 inword = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001885 end = start = smp->data.u.str.str;
1886 while (end - smp->data.u.str.str < smp->data.u.str.len) {
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001887 issep = 0;
1888 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
1889 if (*end == arg_p[1].data.str.str[i]) {
1890 issep = 1;
1891 break;
1892 }
1893 }
1894 if (!inword) {
1895 if (!issep) {
1896 word++;
1897 start = end;
1898 inword = 1;
1899 }
1900 }
1901 else if (issep) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001902 if (word == arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001903 goto found;
1904 inword = 0;
1905 }
1906 end++;
1907 }
1908
1909 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001910 if (word != arg_p[0].data.sint) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001911 smp->data.u.str.len = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001912 return 1;
1913 }
1914found:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001915 smp->data.u.str.len = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001916 /* If ret string is len 0, no need to
1917 change pointers or to update size */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001918 if (!smp->data.u.str.len)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001919 return 1;
1920
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001921 smp->data.u.str.str = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001922
1923 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001924 Note: smp->data.u.str.size cannot be set to 0 */
1925 if (smp->data.u.str.size)
1926 smp->data.u.str.size -= start - smp->data.u.str.str;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001927
1928 return 1;
1929}
1930
Willy Tarreau7eda8492015-01-20 19:47:06 +01001931static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
1932 const char *file, int line, char **err)
1933{
1934 struct arg *arg = args;
1935 char *p;
1936 int len;
1937
1938 /* arg0 is a regex, it uses type_flag for ICASE and global match */
1939 arg[0].type_flags = 0;
1940
1941 if (arg[2].type != ARGT_STR)
1942 return 1;
1943
1944 p = arg[2].data.str.str;
1945 len = arg[2].data.str.len;
1946 while (len) {
1947 if (*p == 'i') {
1948 arg[0].type_flags |= ARGF_REG_ICASE;
1949 }
1950 else if (*p == 'g') {
1951 arg[0].type_flags |= ARGF_REG_GLOB;
1952 }
1953 else {
1954 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
1955 return 0;
1956 }
1957 p++;
1958 len--;
1959 }
1960 return 1;
1961}
1962
1963/* This sample function is designed to do the equivalent of s/match/replace/ on
1964 * the input string. It applies a regex and restarts from the last matched
1965 * location until nothing matches anymore. First arg is the regex to apply to
1966 * the input string, second arg is the replacement expression.
1967 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001968static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01001969{
1970 char *start, *end;
1971 struct my_regex *reg = arg_p[0].data.reg;
1972 regmatch_t pmatch[MAX_MATCH];
1973 struct chunk *trash = get_trash_chunk();
1974 int flag, max;
1975 int found;
1976
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001977 start = smp->data.u.str.str;
1978 end = start + smp->data.u.str.len;
Willy Tarreau7eda8492015-01-20 19:47:06 +01001979
1980 flag = 0;
1981 while (1) {
1982 /* check for last round which is used to copy remaining parts
1983 * when not running in global replacement mode.
1984 */
1985 found = 0;
1986 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
1987 /* Note: we can have start == end on empty strings or at the end */
1988 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
1989 }
1990
1991 if (!found)
1992 pmatch[0].rm_so = end - start;
1993
1994 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
1995 max = trash->size - trash->len;
1996 if (max && pmatch[0].rm_so > 0) {
1997 if (max > pmatch[0].rm_so)
1998 max = pmatch[0].rm_so;
1999 memcpy(trash->str + trash->len, start, max);
2000 trash->len += max;
2001 }
2002
2003 if (!found)
2004 break;
2005
2006 /* replace the matching part */
2007 max = trash->size - trash->len;
2008 if (max) {
2009 if (max > arg_p[1].data.str.len)
2010 max = arg_p[1].data.str.len;
2011 memcpy(trash->str + trash->len, arg_p[1].data.str.str, max);
2012 trash->len += max;
2013 }
2014
2015 /* stop here if we're done with this string */
2016 if (start >= end)
2017 break;
2018
2019 /* We have a special case for matches of length 0 (eg: "x*y*").
2020 * These ones are considered to match in front of a character,
2021 * so we have to copy that character and skip to the next one.
2022 */
2023 if (!pmatch[0].rm_eo) {
2024 if (trash->len < trash->size)
2025 trash->str[trash->len++] = start[pmatch[0].rm_eo];
2026 pmatch[0].rm_eo++;
2027 }
2028
2029 start += pmatch[0].rm_eo;
2030 flag |= REG_NOTBOL;
2031 }
2032
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002033 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002034 return 1;
2035}
2036
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002037/* This function check an operator entry. It expects a string.
2038 * The string can be an integer or a variable name.
2039 */
2040static int check_operator(struct arg *args, struct sample_conv *conv,
2041 const char *file, int line, char **err)
2042{
2043 const char *str;
2044 const char *end;
2045
2046 /* Try to decode a variable. */
2047 if (vars_check_arg(&args[0], NULL))
2048 return 1;
2049
2050 /* Try to convert an integer */
2051 str = args[0].data.str.str;
2052 end = str + strlen(str);
2053 args[0].data.sint = read_int64(&str, end);
2054 if (*str != '\0') {
2055 memprintf(err, "expects an integer or a variable name");
2056 return 0;
2057 }
2058 args[0].type = ARGT_SINT;
2059 return 1;
2060}
2061
2062/* This fucntion returns a sample struct filled with a arg content.
2063 * If the arg contain an integer, the integer is returned in the
2064 * sample. If the arg contains a variable descriptor, it returns the
2065 * variable value.
2066 *
2067 * This function returns 0 if an error occurs, otherwise it returns 1.
2068 */
2069static inline int sample_conv_var2smp(const struct arg *arg, struct stream *strm, struct sample *smp)
2070{
2071 switch (arg->type) {
2072 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002073 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002074 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002075 return 1;
2076 case ARGT_VAR:
2077 if (!vars_get_by_desc(&arg->data.var, strm, smp))
2078 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002079 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002080 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002081 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002082 return 0;
2083 return 1;
2084 default:
2085 return 0;
2086 }
2087}
2088
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002089/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002090 * result.
2091 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002092static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002093{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002094 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002095 return 1;
2096}
2097
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002098/* Takes a SINT on input, applies a binary "and" with the SINT directly in
2099 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002100 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002101static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002102{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002103 struct sample tmp;
2104
2105 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2106 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002107 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002108 return 1;
2109}
2110
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002111/* Takes a SINT on input, applies a binary "or" with the SINT directly in
2112 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002113 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002114static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002115{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002116 struct sample tmp;
2117
2118 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2119 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002120 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002121 return 1;
2122}
2123
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002124/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
2125 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002126 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002127static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002128{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002129 struct sample tmp;
2130
2131 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2132 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002133 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002134 return 1;
2135}
2136
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002137static inline long long int arith_add(long long int a, long long int b)
2138{
2139 /* Prevent overflow and makes capped calculus.
2140 * We must ensure that the check calculus doesn't
2141 * exceed the signed 64 bits limits.
2142 *
2143 * +----------+----------+
2144 * | a<0 | a>=0 |
2145 * +------+----------+----------+
2146 * | b<0 | MIN-a>b | no check |
2147 * +------+----------+----------+
2148 * | b>=0 | no check | MAX-a<b |
2149 * +------+----------+----------+
2150 */
2151 if ((a ^ b) >= 0) {
2152 /* signs are differents. */
2153 if (a < 0) {
2154 if (LLONG_MIN - a > b)
2155 return LLONG_MIN;
2156 }
2157 if (LLONG_MAX - a < b)
2158 return LLONG_MAX;
2159 }
2160 return a + b;
2161}
2162
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002163/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
2164 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002165 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002166static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002167{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002168 struct sample tmp;
2169
2170 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2171 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002172 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002173 return 1;
2174}
2175
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002176/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
2177 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002178 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002179static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002180 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002181{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002182 struct sample tmp;
2183
2184 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2185 return 0;
2186
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002187 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2188 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2189 * of -LLONG_MIN and correct the result.
2190 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002191 if (tmp.data.u.sint == LLONG_MIN) {
2192 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2193 if (smp->data.u.sint < LLONG_MAX)
2194 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002195 return 1;
2196 }
2197
2198 /* standard substraction: we use the "add" function and negate
2199 * the second operand.
2200 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002201 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002202 return 1;
2203}
2204
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002205/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
2206 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2207 * If the result makes an overflow, then the largest possible quantity is
2208 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002209 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002210static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002211 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002212{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002213 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002214 long long int c;
2215
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002216 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2217 return 0;
2218
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002219 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002220 if (!smp->data.u.sint || !tmp.data.u.sint) {
2221 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002222 return 1;
2223 }
2224
2225 /* The multiply between LLONG_MIN and -1 returns a
2226 * "floting point exception".
2227 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002228 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2229 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002230 return 1;
2231 }
2232
2233 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002234 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002235
2236 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002237 if (smp->data.u.sint != c / tmp.data.u.sint) {
2238 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2239 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002240 return 1;
2241 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002242 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002243 return 1;
2244 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002245 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002246 return 1;
2247}
2248
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002249/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
2250 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2251 * If arg_p makes the result overflow, then the largest possible quantity is
2252 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002253 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002254static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002255 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002256{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002257 struct sample tmp;
2258
2259 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2260 return 0;
2261
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002262 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002263 /* The divide between LLONG_MIN and -1 returns a
2264 * "floting point exception".
2265 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002266 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2267 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002268 return 1;
2269 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002270 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002271 return 1;
2272 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002273 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002274 return 1;
2275}
2276
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002277/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
2278 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2279 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002280 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002281static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002282 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002283{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002284 struct sample tmp;
2285
2286 if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
2287 return 0;
2288
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002289 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002290 /* The divide between LLONG_MIN and -1 returns a
2291 * "floting point exception".
2292 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002293 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2294 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002295 return 1;
2296 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002297 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002298 return 1;
2299 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002300 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002301 return 1;
2302}
2303
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002304/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002305 * result.
2306 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002307static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002308 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002309{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002310 if (smp->data.u.sint == LLONG_MIN)
2311 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002312 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002313 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002314 return 1;
2315}
2316
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002317/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002318 * false. The output is a BOOL.
2319 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002320static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002321 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002322{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002323 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002324 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002325 return 1;
2326}
2327
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002328/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002329 * truee. The output is a BOOL.
2330 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002331static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002332 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002333{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002334 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002335 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002336 return 1;
2337}
2338
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002339/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002340 * The output is a BOOL.
2341 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002342static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002343 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002344{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002345 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002346 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002347 return 1;
2348}
2349
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002350/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002351 * The output is a BOOL.
2352 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002353static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002354 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002355{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002356 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002357 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002358 return 1;
2359}
2360
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002361/************************************************************************/
2362/* All supported sample fetch functions must be declared here */
2363/************************************************************************/
2364
2365/* force TRUE to be returned at the fetch level */
2366static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002367smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002368{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002369 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002370 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002371 return 1;
2372}
2373
2374/* force FALSE to be returned at the fetch level */
2375static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002376smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002377{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002378 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002379 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002380 return 1;
2381}
2382
2383/* retrieve environment variable $1 as a string */
2384static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002385smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002386{
2387 char *env;
2388
2389 if (!args || args[0].type != ARGT_STR)
2390 return 0;
2391
2392 env = getenv(args[0].data.str.str);
2393 if (!env)
2394 return 0;
2395
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002396 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002397 smp->flags = SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002398 smp->data.u.str.str = env;
2399 smp->data.u.str.len = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002400 return 1;
2401}
2402
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002403/* retrieve the current local date in epoch time, and applies an optional offset
2404 * of args[0] seconds.
2405 */
2406static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002407smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002408{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002409 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002410
2411 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002412 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002413 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002414
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002415 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002416 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2417 return 1;
2418}
2419
Willy Tarreau0f30d262014-11-24 16:02:05 +01002420/* returns the number of processes */
2421static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002422smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002423{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002424 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002425 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002426 return 1;
2427}
2428
2429/* returns the number of the current process (between 1 and nbproc */
2430static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002431smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002432{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002433 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002434 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002435 return 1;
2436}
2437
Willy Tarreau84310e22014-02-14 11:59:04 +01002438/* generate a random 32-bit integer for whatever purpose, with an optional
2439 * range specified in argument.
2440 */
2441static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002442smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01002443{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002444 smp->data.u.sint = random();
Willy Tarreau84310e22014-02-14 11:59:04 +01002445
2446 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002447 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002448 smp->data.u.sint = (smp->data.u.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
Willy Tarreau84310e22014-02-14 11:59:04 +01002449
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002450 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01002451 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2452 return 1;
2453}
2454
Willy Tarreau0f30d262014-11-24 16:02:05 +01002455/* returns true if the current process is stopping */
2456static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002457smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002458{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002459 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002460 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002461 return 1;
2462}
2463
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002464static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
2465{
2466 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002467 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002468 smp->data.u.str.str = args[0].data.str.str;
2469 smp->data.u.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002470 return 1;
2471}
2472
2473static int smp_check_const_bool(struct arg *args, char **err)
2474{
2475 if (strcasecmp(args[0].data.str.str, "true") == 0 ||
2476 strcasecmp(args[0].data.str.str, "1") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002477 args[0].type = ARGT_SINT;
2478 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002479 return 1;
2480 }
2481 if (strcasecmp(args[0].data.str.str, "false") == 0 ||
2482 strcasecmp(args[0].data.str.str, "0") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002483 args[0].type = ARGT_SINT;
2484 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002485 return 1;
2486 }
2487 memprintf(err, "Expects 'true', 'false', '0' or '1'");
2488 return 0;
2489}
2490
2491static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
2492{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002493 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002494 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002495 return 1;
2496}
2497
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002498static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002499{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002500 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002501 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002502 return 1;
2503}
2504
2505static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
2506{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002507 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002508 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002509 return 1;
2510}
2511
2512static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
2513{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002514 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002515 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002516 return 1;
2517}
2518
2519static int smp_check_const_bin(struct arg *args, char **err)
2520{
2521 char *binstr;
2522 int binstrlen;
2523
2524 if (!parse_binary(args[0].data.str.str, &binstr, &binstrlen, err))
2525 return 0;
2526 args[0].type = ARGT_STR;
2527 args[0].data.str.str = binstr;
2528 args[0].data.str.len = binstrlen;
2529 return 1;
2530}
2531
2532static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
2533{
2534 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002535 smp->data.type = SMP_T_BIN;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002536 smp->data.u.str.str = args[0].data.str.str;
2537 smp->data.u.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002538 return 1;
2539}
2540
2541static int smp_check_const_meth(struct arg *args, char **err)
2542{
2543 enum http_meth_t meth;
2544 int i;
2545
2546 meth = find_http_meth(args[0].data.str.str, args[0].data.str.len);
2547 if (meth != HTTP_METH_OTHER) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002548 args[0].type = ARGT_SINT;
2549 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002550 } else {
2551 /* Check method avalaibility. A methos is a token defined as :
2552 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
2553 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
2554 * token = 1*tchar
2555 */
2556 for (i = 0; i < args[0].data.str.len; i++) {
2557 if (!http_is_token[(unsigned char)args[0].data.str.str[i]]) {
2558 memprintf(err, "expects valid method.");
2559 return 0;
2560 }
2561 }
2562 }
2563 return 1;
2564}
2565
2566static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
2567{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002568 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002569 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002570 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002571 smp->data.u.meth.meth = args[0].data.sint;
2572 smp->data.u.meth.str.str = "";
2573 smp->data.u.meth.str.len = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002574 } else {
2575 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002576 smp->data.u.meth.meth = HTTP_METH_OTHER;
2577 smp->data.u.meth.str.str = args[0].data.str.str;
2578 smp->data.u.meth.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002579 }
2580 return 1;
2581}
2582
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002583/* Note: must not be declared <const> as its list will be overwritten.
2584 * Note: fetches that may return multiple types must be declared as the lowest
2585 * common denominator, the type that can be casted into all other ones. For
2586 * instance IPv4/IPv6 must be declared IPv4.
2587 */
2588static struct sample_fetch_kw_list smp_kws = {ILH, {
2589 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
2590 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002591 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002592 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
2593 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
2594 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002595 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01002596 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002597
2598 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
2599 { "bool", smp_fetch_const_bool, ARG1(1,STR), smp_check_const_bool, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002600 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002601 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
2602 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
2603 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
2604 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
2605
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002606 { /* END */ },
2607}};
2608
Emeric Brun107ca302010-01-04 16:16:05 +01002609/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02002610static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER9687c772015-05-07 15:46:29 +02002611#ifdef DEBUG_EXPR
2612 { "debug", sample_conv_debug, 0, NULL, SMP_T_ANY, SMP_T_ANY },
2613#endif
2614
Emeric Brun53d1a982014-04-30 18:21:37 +02002615 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002616 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
2617 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002618 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002619 { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002620 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
2621 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002622 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2623 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2624 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2625 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002626 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002627 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
2628 { "field", sample_conv_field, ARG2(2,SINT,STR), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
2629 { "word", sample_conv_word, ARG2(2,SINT,STR), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
Willy Tarreau7eda8492015-01-20 19:47:06 +01002630 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
Willy Tarreau97707872015-01-27 15:12:13 +01002631
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002632 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2633 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2634 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2635 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
2636 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2637 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2638 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2639 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2640 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2641 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2642 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2643 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2644 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2645 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01002646
Willy Tarreau9fcb9842012-04-20 14:45:49 +02002647 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01002648}};
2649
2650__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02002651static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01002652{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002653 /* register sample fetch and format conversion keywords */
2654 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02002655 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01002656}