blob: 8a2fa4f3c6db0671c27fd89d31da863a90f2b5b0 [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
Vincent Bernat02779b62016-04-03 13:48:43 +0200858 expr = calloc(1, sizeof(*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;
Vincent Bernat02779b62016-04-03 13:48:43 +0200961 conv_expr = calloc(1, sizeof(*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
Willy Tarreau1777ea62016-03-10 16:15:46 +01001043 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001044 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001045 return NULL;
1046
Emeric Brun107ca302010-01-04 16:16:05 +01001047 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001048 /* we want to ensure that p->type can be casted into
1049 * conv_expr->conv->in_type. We have 3 possibilities :
1050 * - NULL => not castable.
1051 * - c_none => nothing to do (let's optimize it)
1052 * - other => apply cast and prepare to fail
1053 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001054 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001055 return NULL;
1056
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001057 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1058 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001059 return NULL;
1060
Willy Tarreau12e50112012-04-25 17:21:49 +02001061 /* OK cast succeeded */
1062
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001063 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001064 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001065 }
1066 return p;
1067}
1068
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001069/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001070 * Resolve all remaining arguments in proxy <p>. Returns the number of
1071 * errors or 0 if everything is fine.
1072 */
1073int smp_resolve_args(struct proxy *p)
1074{
1075 struct arg_list *cur, *bak;
1076 const char *ctx, *where;
1077 const char *conv_ctx, *conv_pre, *conv_pos;
1078 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001079 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001080 struct arg *arg;
1081 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001082 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001083
1084 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1085 struct proxy *px;
1086 struct server *srv;
1087 char *pname, *sname;
Willy Tarreau46947782015-01-19 19:00:58 +01001088 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001089
1090 arg = cur->arg;
1091
1092 /* prepare output messages */
1093 conv_pre = conv_pos = conv_ctx = "";
1094 if (cur->conv) {
1095 conv_ctx = cur->conv;
1096 conv_pre = "conversion keyword '";
1097 conv_pos = "' for ";
1098 }
1099
1100 where = "in";
1101 ctx = "sample fetch keyword";
1102 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001103 case ARGC_STK: where = "in stick rule in"; break;
1104 case ARGC_TRK: where = "in tracking rule in"; break;
1105 case ARGC_LOG: where = "in log-format string in"; break;
1106 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1107 case ARGC_HRQ: where = "in http-request header format string in"; break;
1108 case ARGC_HRS: where = "in http-response header format string in"; break;
1109 case ARGC_UIF: where = "in unique-id-format string in"; break;
1110 case ARGC_RDR: where = "in redirect format string in"; break;
1111 case ARGC_CAP: where = "in capture rule in"; break;
1112 case ARGC_ACL: ctx = "ACL keyword"; break;
1113 case ARGC_SRV: where = "in server directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001114 }
1115
1116 /* set a few default settings */
1117 px = p;
1118 pname = p->id;
1119
1120 switch (arg->type) {
1121 case ARGT_SRV:
1122 if (!arg->data.str.len) {
1123 Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1124 cur->file, cur->line,
1125 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1126 cfgerr++;
1127 continue;
1128 }
1129
1130 /* we support two formats : "bck/srv" and "srv" */
1131 sname = strrchr(arg->data.str.str, '/');
1132
1133 if (sname) {
1134 *sname++ = '\0';
1135 pname = arg->data.str.str;
1136
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001137 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001138 if (!px) {
1139 Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1140 cur->file, cur->line, pname,
1141 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1142 cfgerr++;
1143 break;
1144 }
1145 }
1146 else
1147 sname = arg->data.str.str;
1148
1149 srv = findserver(px, sname);
1150 if (!srv) {
1151 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",
1152 cur->file, cur->line, sname, pname,
1153 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1154 cfgerr++;
1155 break;
1156 }
1157
1158 free(arg->data.str.str);
1159 arg->data.str.str = NULL;
1160 arg->unresolved = 0;
1161 arg->data.srv = srv;
1162 break;
1163
1164 case ARGT_FE:
1165 if (arg->data.str.len) {
1166 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001167 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001168 }
1169
1170 if (!px) {
1171 Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1172 cur->file, cur->line, pname,
1173 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1174 cfgerr++;
1175 break;
1176 }
1177
1178 if (!(px->cap & PR_CAP_FE)) {
1179 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1180 cur->file, cur->line, pname,
1181 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1182 cfgerr++;
1183 break;
1184 }
1185
1186 free(arg->data.str.str);
1187 arg->data.str.str = NULL;
1188 arg->unresolved = 0;
1189 arg->data.prx = px;
1190 break;
1191
1192 case ARGT_BE:
1193 if (arg->data.str.len) {
1194 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001195 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001196 }
1197
1198 if (!px) {
1199 Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1200 cur->file, cur->line, pname,
1201 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1202 cfgerr++;
1203 break;
1204 }
1205
1206 if (!(px->cap & PR_CAP_BE)) {
1207 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1208 cur->file, cur->line, pname,
1209 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1210 cfgerr++;
1211 break;
1212 }
1213
1214 free(arg->data.str.str);
1215 arg->data.str.str = NULL;
1216 arg->unresolved = 0;
1217 arg->data.prx = px;
1218 break;
1219
1220 case ARGT_TAB:
1221 if (arg->data.str.len) {
1222 pname = arg->data.str.str;
Willy Tarreaue2dc1fa2015-05-26 12:08:07 +02001223 px = proxy_tbl_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001224 }
1225
1226 if (!px) {
1227 Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1228 cur->file, cur->line, pname,
1229 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1230 cfgerr++;
1231 break;
1232 }
1233
1234 if (!px->table.size) {
1235 Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1236 cur->file, cur->line, pname,
1237 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1238 cfgerr++;
1239 break;
1240 }
1241
1242 free(arg->data.str.str);
1243 arg->data.str.str = NULL;
1244 arg->unresolved = 0;
1245 arg->data.prx = px;
1246 break;
1247
1248 case ARGT_USR:
1249 if (!arg->data.str.len) {
1250 Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1251 cur->file, cur->line,
1252 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1253 cfgerr++;
1254 break;
1255 }
1256
1257 if (p->uri_auth && p->uri_auth->userlist &&
1258 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1259 ul = p->uri_auth->userlist;
1260 else
1261 ul = auth_find_userlist(arg->data.str.str);
1262
1263 if (!ul) {
1264 Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1265 cur->file, cur->line, arg->data.str.str,
1266 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1267 cfgerr++;
1268 break;
1269 }
1270
1271 free(arg->data.str.str);
1272 arg->data.str.str = NULL;
1273 arg->unresolved = 0;
1274 arg->data.usr = ul;
1275 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001276
1277 case ARGT_REG:
1278 if (!arg->data.str.len) {
1279 Alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1280 cur->file, cur->line,
1281 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1282 cfgerr++;
1283 continue;
1284 }
1285
1286 reg = calloc(1, sizeof(*reg));
1287 if (!reg) {
1288 Alert("parsing [%s:%d] : not enough memory to build regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1289 cur->file, cur->line,
1290 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1291 cfgerr++;
1292 continue;
1293 }
1294
1295 rflags = 0;
1296 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1297 err = NULL;
1298
Willy Tarreaud817e462015-01-23 20:23:17 +01001299 if (!regex_comp(arg->data.str.str, reg, !(rflags & REG_ICASE), 1 /* capture substr */, &err)) {
Willy Tarreau46947782015-01-19 19:00:58 +01001300 Alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1301 cur->file, cur->line,
1302 arg->data.str.str,
1303 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
1304 cfgerr++;
1305 continue;
1306 }
1307
1308 free(arg->data.str.str);
1309 arg->data.str.str = NULL;
1310 arg->unresolved = 0;
1311 arg->data.reg = reg;
1312 break;
1313
1314
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001315 }
1316
1317 LIST_DEL(&cur->list);
1318 free(cur);
1319 } /* end of args processing */
1320
1321 return cfgerr;
1322}
1323
1324/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001325 * Process a fetch + format conversion as defined by the sample expression
1326 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001327 * not explicitly set to <smp_type>, but shall be compatible with it as
1328 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1329 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001330 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1331 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1332 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1333 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001334 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1335 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1336 * still hope to get it after waiting longer, and is not converted to string.
1337 * The possible output combinations are the following :
1338 *
1339 * return MAY_CHANGE FINAL Meaning for the sample
1340 * NULL * * Not present and will never be (eg: header)
1341 * smp 0 * Final value converted (eg: header)
1342 * smp 1 0 Not present yet, may appear later (eg: header)
1343 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001344 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001345struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001346 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001347 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001348{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001349 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001350
Willy Tarreau6c616e02014-06-25 16:56:41 +02001351 memset(smp, 0, sizeof(*smp));
1352
Willy Tarreau192252e2015-04-04 01:47:55 +02001353 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001354 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1355 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001356 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001357 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001358
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001359 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001360 return NULL;
1361
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001362 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001363 return NULL;
1364
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001365 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001366 return smp;
1367}
1368
Emeric Brun107ca302010-01-04 16:16:05 +01001369/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001370/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001371/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001372/*****************************************************************/
1373
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001374#ifdef DEBUG_EXPR
1375static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1376{
1377 int i;
1378 struct sample tmp;
1379
1380 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001381 fprintf(stderr, "[debug converter] type: %s ", smp_to_type[smp->data.type]);
1382 if (!sample_casts[smp->data.type][SMP_T_STR]) {
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001383 fprintf(stderr, "(undisplayable)");
1384 } else {
1385
1386 /* Copy sample fetch. This put the sample as const, the
1387 * cast will copy data if a transformation is required.
1388 */
1389 memcpy(&tmp, smp, sizeof(struct sample));
1390 tmp.flags = SMP_F_CONST;
1391
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001392 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001393 fprintf(stderr, "(undisplayable)");
1394
1395 else {
1396 /* Display the displayable chars*. */
1397 fprintf(stderr, "<");
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001398 for (i = 0; i < tmp.data.u.str.len; i++) {
1399 if (isprint(tmp.data.u.str.str[i]))
1400 fputc(tmp.data.u.str.str[i], stderr);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001401 else
1402 fputc('.', stderr);
1403 }
1404 }
1405 fprintf(stderr, ">\n");
1406 }
1407 }
1408 return 1;
1409}
1410#endif
1411
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001412static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001413{
1414 struct chunk *trash = get_trash_chunk();
1415 int b64_len;
1416
1417 trash->len = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001418 b64_len = a2base64(smp->data.u.str.str, smp->data.u.str.len, trash->str, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001419 if (b64_len < 0)
1420 return 0;
1421
1422 trash->len = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001423 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001424 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001425 smp->flags &= ~SMP_F_CONST;
1426 return 1;
1427}
1428
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001429static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001430{
1431 struct chunk *trash = get_trash_chunk();
1432 unsigned char c;
1433 int ptr = 0;
1434
1435 trash->len = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001436 while (ptr < smp->data.u.str.len && trash->len <= trash->size - 2) {
1437 c = smp->data.u.str.str[ptr++];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001438 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
1439 trash->str[trash->len++] = hextab[c & 0xF];
1440 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001441 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001442 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001443 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001444 return 1;
1445}
1446
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001447/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001448static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001449{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001450 smp->data.u.sint = hash_djb2(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001451 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001452 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001453 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001454 return 1;
1455}
1456
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001457static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001458{
1459 int i;
1460
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001461 if (!smp_dup(smp))
1462 return 0;
1463
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001464 if (!smp->data.u.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001465 return 0;
1466
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001467 for (i = 0; i < smp->data.u.str.len; i++) {
1468 if ((smp->data.u.str.str[i] >= 'A') && (smp->data.u.str.str[i] <= 'Z'))
1469 smp->data.u.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001470 }
1471 return 1;
1472}
1473
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001474static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001475{
1476 int i;
1477
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001478 if (!smp_dup(smp))
1479 return 0;
1480
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001481 if (!smp->data.u.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001482 return 0;
1483
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001484 for (i = 0; i < smp->data.u.str.len; i++) {
1485 if ((smp->data.u.str.str[i] >= 'a') && (smp->data.u.str.str[i] <= 'z'))
1486 smp->data.u.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001487 }
1488 return 1;
1489}
1490
Willy Tarreauf9954102012-04-20 14:03:29 +02001491/* takes the netmask in arg_p */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001492static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001493{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001494 smp->data.u.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001495 smp->data.type = SMP_T_IPV4;
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001496 return 1;
1497}
1498
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001499/* takes an UINT value on input supposed to represent the time since EPOCH,
1500 * adds an optional offset found in args[1] and emits a string representing
1501 * the local time in the format specified in args[1] using strftime().
1502 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001503static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001504{
1505 struct chunk *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001506 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001507 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001508 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001509
1510 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001511 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001512 curr_date += args[1].data.sint;
1513
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001514 tm = localtime(&curr_date);
1515 if (!tm)
1516 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001517 temp = get_trash_chunk();
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001518 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001519 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001520 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001521 return 1;
1522}
1523
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001524/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001525static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001526{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001527 smp->data.u.sint = hash_sdbm(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001528 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001529 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001530 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001531 return 1;
1532}
1533
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001534/* takes an UINT value on input supposed to represent the time since EPOCH,
1535 * adds an optional offset found in args[1] and emits a string representing
1536 * the UTC date in the format specified in args[1] using strftime().
1537 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001538static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001539{
1540 struct chunk *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001541 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001542 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001543 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001544
1545 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001546 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001547 curr_date += args[1].data.sint;
1548
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001549 tm = gmtime(&curr_date);
1550 if (!tm)
1551 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001552 temp = get_trash_chunk();
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001553 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001554 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001555 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001556 return 1;
1557}
1558
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001559/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001560static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001561{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001562 smp->data.u.sint = hash_wt6(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001563 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001564 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001565 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001566 return 1;
1567}
1568
Willy Tarreau80599772015-01-20 19:35:24 +01001569/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001570static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01001571{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001572 smp->data.u.sint = hash_crc32(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001573 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001574 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001575 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01001576 return 1;
1577}
1578
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001579/* This function escape special json characters. The returned string can be
1580 * safely set between two '"' and used as json string. The json string is
1581 * defined like this:
1582 *
1583 * any Unicode character except '"' or '\' or control character
1584 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
1585 *
1586 * The enum input_type contain all the allowed mode for decoding the input
1587 * string.
1588 */
1589enum input_type {
1590 IT_ASCII = 0,
1591 IT_UTF8,
1592 IT_UTF8S,
1593 IT_UTF8P,
1594 IT_UTF8PS,
1595};
1596static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
1597 const char *file, int line, char **err)
1598{
1599 if (!arg) {
1600 memprintf(err, "Unexpected empty arg list");
1601 return 0;
1602 }
1603
1604 if (arg->type != ARGT_STR) {
1605 memprintf(err, "Unexpected arg type");
1606 return 0;
1607 }
1608
1609 if (strcmp(arg->data.str.str, "") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001610 arg->type = ARGT_SINT;
1611 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001612 return 1;
1613 }
1614
1615 else if (strcmp(arg->data.str.str, "ascii") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001616 arg->type = ARGT_SINT;
1617 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001618 return 1;
1619 }
1620
1621 else if (strcmp(arg->data.str.str, "utf8") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001622 arg->type = ARGT_SINT;
1623 arg->data.sint = IT_UTF8;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001624 return 1;
1625 }
1626
1627 else if (strcmp(arg->data.str.str, "utf8s") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001628 arg->type = ARGT_SINT;
1629 arg->data.sint = IT_UTF8S;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001630 return 1;
1631 }
1632
1633 else if (strcmp(arg->data.str.str, "utf8p") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001634 arg->type = ARGT_SINT;
1635 arg->data.sint = IT_UTF8P;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001636 return 1;
1637 }
1638
1639 else if (strcmp(arg->data.str.str, "utf8ps") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001640 arg->type = ARGT_SINT;
1641 arg->data.sint = IT_UTF8PS;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001642 return 1;
1643 }
1644
1645 memprintf(err, "Unexpected input code type at file '%s', line %d. "
1646 "Allowed value are 'ascii', 'utf8', 'utf8p' and 'utf8pp'", file, line);
1647 return 0;
1648}
1649
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001650static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001651{
1652 struct chunk *temp;
1653 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
1654 const char *str;
1655 int len;
1656 enum input_type input_type = IT_ASCII;
1657 unsigned int c;
1658 unsigned int ret;
1659 char *p;
1660
1661 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001662 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001663
1664 temp = get_trash_chunk();
1665 temp->len = 0;
1666
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001667 p = smp->data.u.str.str;
1668 while (p < smp->data.u.str.str + smp->data.u.str.len) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001669
1670 if (input_type == IT_ASCII) {
1671 /* Read input as ASCII. */
1672 c = *(unsigned char *)p;
1673 p++;
1674 }
1675 else {
1676 /* Read input as UTF8. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001677 ret = utf8_next(p, smp->data.u.str.len - ( p - smp->data.u.str.str ), &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001678 p += utf8_return_length(ret);
1679
1680 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
1681 return 0;
1682 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
1683 continue;
1684 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1685 return 0;
1686 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1687 continue;
1688
1689 /* Check too big values. */
1690 if ((unsigned int)c > 0xffff) {
1691 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
1692 return 0;
1693 continue;
1694 }
1695 }
1696
1697 /* Convert character. */
1698 if (c == '"') {
1699 len = 2;
1700 str = "\\\"";
1701 }
1702 else if (c == '\\') {
1703 len = 2;
1704 str = "\\\\";
1705 }
1706 else if (c == '/') {
1707 len = 2;
1708 str = "\\/";
1709 }
1710 else if (c == '\b') {
1711 len = 2;
1712 str = "\\b";
1713 }
1714 else if (c == '\f') {
1715 len = 2;
1716 str = "\\f";
1717 }
1718 else if (c == '\r') {
1719 len = 2;
1720 str = "\\r";
1721 }
1722 else if (c == '\n') {
1723 len = 2;
1724 str = "\\n";
1725 }
1726 else if (c == '\t') {
1727 len = 2;
1728 str = "\\t";
1729 }
1730 else if (c > 0xff || !isprint(c)) {
1731 /* isprint generate a segfault if c is too big. The man says that
1732 * c must have the value of an unsigned char or EOF.
1733 */
1734 len = 6;
1735 _str[0] = '\\';
1736 _str[1] = 'u';
1737 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
1738 str = _str;
1739 }
1740 else {
1741 len = 1;
1742 str = (char *)&c;
1743 }
1744
1745 /* Check length */
1746 if (temp->len + len > temp->size)
1747 return 0;
1748
1749 /* Copy string. */
1750 memcpy(temp->str + temp->len, str, len);
1751 temp->len += len;
1752 }
1753
1754 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001755 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001756 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001757
1758 return 1;
1759}
1760
Emeric Brun54c4ac82014-11-03 15:32:43 +01001761/* This sample function is designed to extract some bytes from an input buffer.
1762 * First arg is the offset.
1763 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001764static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01001765{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001766 if (smp->data.u.str.len <= arg_p[0].data.sint) {
1767 smp->data.u.str.len = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001768 return 1;
1769 }
1770
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001771 if (smp->data.u.str.size)
1772 smp->data.u.str.size -= arg_p[0].data.sint;
1773 smp->data.u.str.len -= arg_p[0].data.sint;
1774 smp->data.u.str.str += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001775
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001776 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.len))
1777 smp->data.u.str.len = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001778
1779 return 1;
1780}
1781
Emeric Brunf399b0d2014-11-03 17:07:03 +01001782static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
1783 const char *file, int line, char **err)
1784{
1785 struct arg *arg = args;
1786
1787 if (!arg) {
1788 memprintf(err, "Unexpected empty arg list");
1789 return 0;
1790 }
1791
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001792 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001793 memprintf(err, "Unexpected arg type");
1794 return 0;
1795 }
1796
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001797 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001798 memprintf(err, "Unexpected value 0 for index");
1799 return 0;
1800 }
1801
1802 arg++;
1803
1804 if (arg->type != ARGT_STR) {
1805 memprintf(err, "Unexpected arg type");
1806 return 0;
1807 }
1808
1809 if (!arg->data.str.len) {
1810 memprintf(err, "Empty separators list");
1811 return 0;
1812 }
1813
1814 return 1;
1815}
1816
1817/* This sample function is designed to a return selected part of a string (field).
1818 * First arg is the index of the field (start at 1)
1819 * Second arg is a char list of separators (type string)
1820 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001821static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001822{
1823 unsigned int field;
1824 char *start, *end;
1825 int i;
1826
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001827 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001828 return 0;
1829
1830 field = 1;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001831 end = start = smp->data.u.str.str;
1832 while (end - smp->data.u.str.str < smp->data.u.str.len) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001833
1834 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
1835 if (*end == arg_p[1].data.str.str[i]) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001836 if (field == arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001837 goto found;
1838 start = end+1;
1839 field++;
1840 break;
1841 }
1842 }
1843 end++;
1844 }
1845
1846 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001847 if (field != arg_p[0].data.sint) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001848 smp->data.u.str.len = 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001849 return 1;
1850 }
1851found:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001852 smp->data.u.str.len = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001853 /* If ret string is len 0, no need to
1854 change pointers or to update size */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001855 if (!smp->data.u.str.len)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001856 return 1;
1857
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001858 smp->data.u.str.str = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001859
1860 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001861 Note: smp->data.u.str.size cannot be set to 0 */
1862 if (smp->data.u.str.size)
1863 smp->data.u.str.size -= start - smp->data.u.str.str;
Emeric Brunf399b0d2014-11-03 17:07:03 +01001864
1865 return 1;
1866}
1867
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001868/* This sample function is designed to return a word from a string.
1869 * First arg is the index of the word (start at 1)
1870 * Second arg is a char list of words separators (type string)
1871 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001872static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001873{
1874 unsigned int word;
1875 char *start, *end;
1876 int i, issep, inword;
1877
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001878 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001879 return 0;
1880
1881 word = 0;
1882 inword = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001883 end = start = smp->data.u.str.str;
1884 while (end - smp->data.u.str.str < smp->data.u.str.len) {
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001885 issep = 0;
1886 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
1887 if (*end == arg_p[1].data.str.str[i]) {
1888 issep = 1;
1889 break;
1890 }
1891 }
1892 if (!inword) {
1893 if (!issep) {
1894 word++;
1895 start = end;
1896 inword = 1;
1897 }
1898 }
1899 else if (issep) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001900 if (word == arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001901 goto found;
1902 inword = 0;
1903 }
1904 end++;
1905 }
1906
1907 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001908 if (word != arg_p[0].data.sint) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001909 smp->data.u.str.len = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001910 return 1;
1911 }
1912found:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001913 smp->data.u.str.len = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001914 /* If ret string is len 0, no need to
1915 change pointers or to update size */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001916 if (!smp->data.u.str.len)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001917 return 1;
1918
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001919 smp->data.u.str.str = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001920
1921 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001922 Note: smp->data.u.str.size cannot be set to 0 */
1923 if (smp->data.u.str.size)
1924 smp->data.u.str.size -= start - smp->data.u.str.str;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001925
1926 return 1;
1927}
1928
Willy Tarreau7eda8492015-01-20 19:47:06 +01001929static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
1930 const char *file, int line, char **err)
1931{
1932 struct arg *arg = args;
1933 char *p;
1934 int len;
1935
1936 /* arg0 is a regex, it uses type_flag for ICASE and global match */
1937 arg[0].type_flags = 0;
1938
1939 if (arg[2].type != ARGT_STR)
1940 return 1;
1941
1942 p = arg[2].data.str.str;
1943 len = arg[2].data.str.len;
1944 while (len) {
1945 if (*p == 'i') {
1946 arg[0].type_flags |= ARGF_REG_ICASE;
1947 }
1948 else if (*p == 'g') {
1949 arg[0].type_flags |= ARGF_REG_GLOB;
1950 }
1951 else {
1952 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
1953 return 0;
1954 }
1955 p++;
1956 len--;
1957 }
1958 return 1;
1959}
1960
1961/* This sample function is designed to do the equivalent of s/match/replace/ on
1962 * the input string. It applies a regex and restarts from the last matched
1963 * location until nothing matches anymore. First arg is the regex to apply to
1964 * the input string, second arg is the replacement expression.
1965 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001966static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01001967{
1968 char *start, *end;
1969 struct my_regex *reg = arg_p[0].data.reg;
1970 regmatch_t pmatch[MAX_MATCH];
1971 struct chunk *trash = get_trash_chunk();
1972 int flag, max;
1973 int found;
1974
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001975 start = smp->data.u.str.str;
1976 end = start + smp->data.u.str.len;
Willy Tarreau7eda8492015-01-20 19:47:06 +01001977
1978 flag = 0;
1979 while (1) {
1980 /* check for last round which is used to copy remaining parts
1981 * when not running in global replacement mode.
1982 */
1983 found = 0;
1984 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
1985 /* Note: we can have start == end on empty strings or at the end */
1986 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
1987 }
1988
1989 if (!found)
1990 pmatch[0].rm_so = end - start;
1991
1992 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
1993 max = trash->size - trash->len;
1994 if (max && pmatch[0].rm_so > 0) {
1995 if (max > pmatch[0].rm_so)
1996 max = pmatch[0].rm_so;
1997 memcpy(trash->str + trash->len, start, max);
1998 trash->len += max;
1999 }
2000
2001 if (!found)
2002 break;
2003
2004 /* replace the matching part */
2005 max = trash->size - trash->len;
2006 if (max) {
2007 if (max > arg_p[1].data.str.len)
2008 max = arg_p[1].data.str.len;
2009 memcpy(trash->str + trash->len, arg_p[1].data.str.str, max);
2010 trash->len += max;
2011 }
2012
2013 /* stop here if we're done with this string */
2014 if (start >= end)
2015 break;
2016
2017 /* We have a special case for matches of length 0 (eg: "x*y*").
2018 * These ones are considered to match in front of a character,
2019 * so we have to copy that character and skip to the next one.
2020 */
2021 if (!pmatch[0].rm_eo) {
2022 if (trash->len < trash->size)
2023 trash->str[trash->len++] = start[pmatch[0].rm_eo];
2024 pmatch[0].rm_eo++;
2025 }
2026
2027 start += pmatch[0].rm_eo;
2028 flag |= REG_NOTBOL;
2029 }
2030
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002031 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002032 return 1;
2033}
2034
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002035/* This function check an operator entry. It expects a string.
2036 * The string can be an integer or a variable name.
2037 */
2038static int check_operator(struct arg *args, struct sample_conv *conv,
2039 const char *file, int line, char **err)
2040{
2041 const char *str;
2042 const char *end;
2043
2044 /* Try to decode a variable. */
2045 if (vars_check_arg(&args[0], NULL))
2046 return 1;
2047
2048 /* Try to convert an integer */
2049 str = args[0].data.str.str;
2050 end = str + strlen(str);
2051 args[0].data.sint = read_int64(&str, end);
2052 if (*str != '\0') {
2053 memprintf(err, "expects an integer or a variable name");
2054 return 0;
2055 }
2056 args[0].type = ARGT_SINT;
2057 return 1;
2058}
2059
Willy Tarreau6204cd92016-03-10 16:33:04 +01002060/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002061 * If the arg contain an integer, the integer is returned in the
2062 * sample. If the arg contains a variable descriptor, it returns the
2063 * variable value.
2064 *
2065 * This function returns 0 if an error occurs, otherwise it returns 1.
2066 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002067static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002068{
2069 switch (arg->type) {
2070 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002071 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002072 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002073 return 1;
2074 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002075 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002076 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002077 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002078 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002079 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002080 return 0;
2081 return 1;
2082 default:
2083 return 0;
2084 }
2085}
2086
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002087/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002088 * result.
2089 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002090static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002091{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002092 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002093 return 1;
2094}
2095
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002096/* Takes a SINT on input, applies a binary "and" with the SINT directly in
2097 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002098 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002099static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002100{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002101 struct sample tmp;
2102
Willy Tarreau7560dd42016-03-10 16:28:58 +01002103 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002104 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002105 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002106 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002107 return 1;
2108}
2109
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002110/* Takes a SINT on input, applies a binary "or" with the SINT directly in
2111 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002112 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002113static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002114{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002115 struct sample tmp;
2116
Willy Tarreau7560dd42016-03-10 16:28:58 +01002117 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002118 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002119 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
Willy Tarreau7560dd42016-03-10 16:28:58 +01002131 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002132 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002133 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002134 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002135 return 1;
2136}
2137
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002138static inline long long int arith_add(long long int a, long long int b)
2139{
2140 /* Prevent overflow and makes capped calculus.
2141 * We must ensure that the check calculus doesn't
2142 * exceed the signed 64 bits limits.
2143 *
2144 * +----------+----------+
2145 * | a<0 | a>=0 |
2146 * +------+----------+----------+
2147 * | b<0 | MIN-a>b | no check |
2148 * +------+----------+----------+
2149 * | b>=0 | no check | MAX-a<b |
2150 * +------+----------+----------+
2151 */
2152 if ((a ^ b) >= 0) {
2153 /* signs are differents. */
2154 if (a < 0) {
2155 if (LLONG_MIN - a > b)
2156 return LLONG_MIN;
2157 }
2158 if (LLONG_MAX - a < b)
2159 return LLONG_MAX;
2160 }
2161 return a + b;
2162}
2163
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002164/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
2165 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002166 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002167static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002168{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002169 struct sample tmp;
2170
Willy Tarreau7560dd42016-03-10 16:28:58 +01002171 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002172 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002173 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002174 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002175 return 1;
2176}
2177
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002178/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
2179 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002180 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002181static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002182 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002183{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002184 struct sample tmp;
2185
Willy Tarreau7560dd42016-03-10 16:28:58 +01002186 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002187 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002188 return 0;
2189
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002190 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2191 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2192 * of -LLONG_MIN and correct the result.
2193 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002194 if (tmp.data.u.sint == LLONG_MIN) {
2195 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2196 if (smp->data.u.sint < LLONG_MAX)
2197 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002198 return 1;
2199 }
2200
2201 /* standard substraction: we use the "add" function and negate
2202 * the second operand.
2203 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002204 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002205 return 1;
2206}
2207
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002208/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
2209 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2210 * If the result makes an overflow, then the largest possible quantity is
2211 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002212 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002213static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002214 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002215{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002216 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002217 long long int c;
2218
Willy Tarreau7560dd42016-03-10 16:28:58 +01002219 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002220 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002221 return 0;
2222
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002223 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002224 if (!smp->data.u.sint || !tmp.data.u.sint) {
2225 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002226 return 1;
2227 }
2228
2229 /* The multiply between LLONG_MIN and -1 returns a
2230 * "floting point exception".
2231 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002232 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2233 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002234 return 1;
2235 }
2236
2237 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002238 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002239
2240 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002241 if (smp->data.u.sint != c / tmp.data.u.sint) {
2242 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2243 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002244 return 1;
2245 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002246 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002247 return 1;
2248 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002249 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002250 return 1;
2251}
2252
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002253/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
2254 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2255 * If arg_p makes the result overflow, then the largest possible quantity is
2256 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002257 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002258static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002259 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002260{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002261 struct sample tmp;
2262
Willy Tarreau7560dd42016-03-10 16:28:58 +01002263 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002264 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002265 return 0;
2266
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002267 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002268 /* The divide between LLONG_MIN and -1 returns a
2269 * "floting point exception".
2270 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002271 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2272 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002273 return 1;
2274 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002275 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002276 return 1;
2277 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002278 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002279 return 1;
2280}
2281
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002282/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
2283 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2284 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002285 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002286static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002287 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002288{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002289 struct sample tmp;
2290
Willy Tarreau7560dd42016-03-10 16:28:58 +01002291 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002292 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002293 return 0;
2294
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002295 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002296 /* The divide between LLONG_MIN and -1 returns a
2297 * "floting point exception".
2298 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002299 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2300 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002301 return 1;
2302 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002303 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002304 return 1;
2305 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002306 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002307 return 1;
2308}
2309
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002310/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002311 * result.
2312 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002313static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002314 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002315{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002316 if (smp->data.u.sint == LLONG_MIN)
2317 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002318 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002319 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002320 return 1;
2321}
2322
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002323/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002324 * false. The output is a BOOL.
2325 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002326static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002327 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002328{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002329 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002330 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002331 return 1;
2332}
2333
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002334/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002335 * truee. The output is a BOOL.
2336 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002337static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002338 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002339{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002340 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002341 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002342 return 1;
2343}
2344
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002345/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002346 * The output is a BOOL.
2347 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002348static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002349 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002350{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002351 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002352 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002353 return 1;
2354}
2355
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002356/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002357 * The output is a BOOL.
2358 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002359static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002360 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002361{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002362 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002363 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002364 return 1;
2365}
2366
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002367/************************************************************************/
2368/* All supported sample fetch functions must be declared here */
2369/************************************************************************/
2370
2371/* force TRUE to be returned at the fetch level */
2372static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002373smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002374{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002375 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002376 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002377 return 1;
2378}
2379
2380/* force FALSE to be returned at the fetch level */
2381static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002382smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002383{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002384 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002385 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002386 return 1;
2387}
2388
2389/* retrieve environment variable $1 as a string */
2390static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002391smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002392{
2393 char *env;
2394
2395 if (!args || args[0].type != ARGT_STR)
2396 return 0;
2397
2398 env = getenv(args[0].data.str.str);
2399 if (!env)
2400 return 0;
2401
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002402 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002403 smp->flags = SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002404 smp->data.u.str.str = env;
2405 smp->data.u.str.len = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002406 return 1;
2407}
2408
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002409/* retrieve the current local date in epoch time, and applies an optional offset
2410 * of args[0] seconds.
2411 */
2412static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002413smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002414{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002415 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002416
2417 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002418 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002419 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002420
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002421 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002422 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2423 return 1;
2424}
2425
Willy Tarreau0f30d262014-11-24 16:02:05 +01002426/* returns the number of processes */
2427static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002428smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002429{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002430 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002431 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002432 return 1;
2433}
2434
2435/* returns the number of the current process (between 1 and nbproc */
2436static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002437smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002438{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002439 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002440 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002441 return 1;
2442}
2443
Willy Tarreau84310e22014-02-14 11:59:04 +01002444/* generate a random 32-bit integer for whatever purpose, with an optional
2445 * range specified in argument.
2446 */
2447static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002448smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01002449{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002450 smp->data.u.sint = random();
Willy Tarreau84310e22014-02-14 11:59:04 +01002451
2452 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002453 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002454 smp->data.u.sint = (smp->data.u.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
Willy Tarreau84310e22014-02-14 11:59:04 +01002455
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002456 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01002457 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2458 return 1;
2459}
2460
Willy Tarreau0f30d262014-11-24 16:02:05 +01002461/* returns true if the current process is stopping */
2462static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002463smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002464{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002465 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002466 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002467 return 1;
2468}
2469
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002470static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
2471{
2472 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002473 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002474 smp->data.u.str.str = args[0].data.str.str;
2475 smp->data.u.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002476 return 1;
2477}
2478
2479static int smp_check_const_bool(struct arg *args, char **err)
2480{
2481 if (strcasecmp(args[0].data.str.str, "true") == 0 ||
2482 strcasecmp(args[0].data.str.str, "1") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002483 args[0].type = ARGT_SINT;
2484 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002485 return 1;
2486 }
2487 if (strcasecmp(args[0].data.str.str, "false") == 0 ||
2488 strcasecmp(args[0].data.str.str, "0") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002489 args[0].type = ARGT_SINT;
2490 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002491 return 1;
2492 }
2493 memprintf(err, "Expects 'true', 'false', '0' or '1'");
2494 return 0;
2495}
2496
2497static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
2498{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002499 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002500 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002501 return 1;
2502}
2503
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002504static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002505{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002506 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002507 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002508 return 1;
2509}
2510
2511static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
2512{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002513 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002514 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002515 return 1;
2516}
2517
2518static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
2519{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002520 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002521 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002522 return 1;
2523}
2524
2525static int smp_check_const_bin(struct arg *args, char **err)
2526{
2527 char *binstr;
2528 int binstrlen;
2529
2530 if (!parse_binary(args[0].data.str.str, &binstr, &binstrlen, err))
2531 return 0;
2532 args[0].type = ARGT_STR;
2533 args[0].data.str.str = binstr;
2534 args[0].data.str.len = binstrlen;
2535 return 1;
2536}
2537
2538static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
2539{
2540 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002541 smp->data.type = SMP_T_BIN;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002542 smp->data.u.str.str = args[0].data.str.str;
2543 smp->data.u.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002544 return 1;
2545}
2546
2547static int smp_check_const_meth(struct arg *args, char **err)
2548{
2549 enum http_meth_t meth;
2550 int i;
2551
2552 meth = find_http_meth(args[0].data.str.str, args[0].data.str.len);
2553 if (meth != HTTP_METH_OTHER) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002554 args[0].type = ARGT_SINT;
2555 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002556 } else {
2557 /* Check method avalaibility. A methos is a token defined as :
2558 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
2559 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
2560 * token = 1*tchar
2561 */
2562 for (i = 0; i < args[0].data.str.len; i++) {
2563 if (!http_is_token[(unsigned char)args[0].data.str.str[i]]) {
2564 memprintf(err, "expects valid method.");
2565 return 0;
2566 }
2567 }
2568 }
2569 return 1;
2570}
2571
2572static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
2573{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002574 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002575 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002576 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002577 smp->data.u.meth.meth = args[0].data.sint;
2578 smp->data.u.meth.str.str = "";
2579 smp->data.u.meth.str.len = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002580 } else {
2581 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002582 smp->data.u.meth.meth = HTTP_METH_OTHER;
2583 smp->data.u.meth.str.str = args[0].data.str.str;
2584 smp->data.u.meth.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002585 }
2586 return 1;
2587}
2588
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002589/* Note: must not be declared <const> as its list will be overwritten.
2590 * Note: fetches that may return multiple types must be declared as the lowest
2591 * common denominator, the type that can be casted into all other ones. For
2592 * instance IPv4/IPv6 must be declared IPv4.
2593 */
2594static struct sample_fetch_kw_list smp_kws = {ILH, {
2595 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
2596 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002597 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002598 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
2599 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
2600 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002601 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01002602 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002603
2604 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
2605 { "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 +02002606 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002607 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
2608 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
2609 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
2610 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
2611
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002612 { /* END */ },
2613}};
2614
Emeric Brun107ca302010-01-04 16:16:05 +01002615/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02002616static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER9687c772015-05-07 15:46:29 +02002617#ifdef DEBUG_EXPR
2618 { "debug", sample_conv_debug, 0, NULL, SMP_T_ANY, SMP_T_ANY },
2619#endif
2620
Emeric Brun53d1a982014-04-30 18:21:37 +02002621 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002622 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
2623 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002624 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002625 { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002626 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
2627 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002628 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2629 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2630 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2631 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002632 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002633 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
2634 { "field", sample_conv_field, ARG2(2,SINT,STR), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
2635 { "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 +01002636 { "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 +01002637
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002638 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2639 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2640 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2641 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
2642 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2643 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2644 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2645 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2646 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2647 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2648 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2649 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2650 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2651 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01002652
Willy Tarreau9fcb9842012-04-20 14:45:49 +02002653 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01002654}};
2655
2656__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02002657static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01002658{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002659 /* register sample fetch and format conversion keywords */
2660 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02002661 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01002662}