blob: 3e1a156f0e9e4d9f5b9910cf0681d4f1803d7303 [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
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +020036#include <import/sha1.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010037#include <import/xxhash.h>
38
Willy Tarreau1cf8f082014-02-07 12:14:54 +010039/* sample type names */
40const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020041 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010042 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010043 [SMP_T_SINT] = "sint",
44 [SMP_T_ADDR] = "addr",
45 [SMP_T_IPV4] = "ipv4",
46 [SMP_T_IPV6] = "ipv6",
47 [SMP_T_STR] = "str",
48 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020049 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010050};
51
Willy Tarreau12785782012-04-27 21:37:17 +020052/* static sample used in sample_process() when <p> is NULL */
Emeric Brune5c918b2017-06-14 14:15:36 +020053static THREAD_LOCAL struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010054
Willy Tarreau12785782012-04-27 21:37:17 +020055/* list head of all known sample fetch keywords */
56static struct sample_fetch_kw_list sample_fetches = {
57 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010058};
59
Willy Tarreau12785782012-04-27 21:37:17 +020060/* list head of all known sample format conversion keywords */
61static struct sample_conv_kw_list sample_convs = {
62 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010063};
64
Willy Tarreau80aca902013-01-07 15:42:20 +010065const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
66 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
67 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
68 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
69 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
70 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
71 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
72 SMP_VAL_FE_LOG_END),
73
74 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
75 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
76 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
77 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
78 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
79 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
80 SMP_VAL_FE_LOG_END),
81
82 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
83 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
84 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
85 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
86 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
87 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
88 SMP_VAL_FE_LOG_END),
89
90 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
91 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
92 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
93 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
94 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
95 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
96 SMP_VAL_FE_LOG_END),
97
98 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
99 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
100 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
101 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
102 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
103 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
104 SMP_VAL_FE_LOG_END),
105
106 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
107 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
108 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
109 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
110 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
111 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
112 SMP_VAL_FE_LOG_END),
113
114 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
115 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
116 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
117 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
118 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
119 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
120 SMP_VAL___________),
121
122 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
123 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
124 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
125 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
126 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
127 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
128 SMP_VAL___________),
129
130 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
131 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
132 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
133 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
134 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
135 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
136 SMP_VAL_FE_LOG_END),
137
138 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
139 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
140 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
141 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
142 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
143 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
144 SMP_VAL___________),
145
146 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
147 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
148 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
149 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
150 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
151 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
152 SMP_VAL_FE_LOG_END),
153
154 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
155 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
156 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
157 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
158 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
159 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
160 SMP_VAL_FE_LOG_END),
161
162 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
163 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
164 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
165 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
166 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
167 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
168 SMP_VAL_FE_LOG_END),
169
170 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
171 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
172 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
173 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
174 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
175 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
176 SMP_VAL_FE_LOG_END),
177
178 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
179 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
180 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
181 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
182 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
183 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
184 SMP_VAL___________),
185
186 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
187 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
188 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
189 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
190 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
191 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
192 SMP_VAL___________),
193
194 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
195 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
196 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
197 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
198 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
199 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
200 SMP_VAL_FE_LOG_END),
201
202 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
203 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
204 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
205 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
206 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
207 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
208 SMP_VAL___________),
209
210 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
211 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
212 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
213 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
214 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
215 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
216 SMP_VAL_FE_LOG_END),
217
218 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
220 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
221 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
222 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
223 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
224 SMP_VAL_FE_LOG_END),
225
226 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
227 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
228 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
229 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
230 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
231 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
232 SMP_VAL_FE_LOG_END),
233
234 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
235 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
236 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
237 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
238 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
239 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
240 SMP_VAL_FE_LOG_END),
241};
242
243static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
244 [SMP_SRC_INTRN] = "internal state",
245 [SMP_SRC_LISTN] = "listener",
246 [SMP_SRC_FTEND] = "frontend",
247 [SMP_SRC_L4CLI] = "client address",
248 [SMP_SRC_L5CLI] = "client-side connection",
249 [SMP_SRC_TRACK] = "track counters",
250 [SMP_SRC_L6REQ] = "request buffer",
251 [SMP_SRC_HRQHV] = "HTTP request headers",
252 [SMP_SRC_HRQHP] = "HTTP request",
253 [SMP_SRC_HRQBO] = "HTTP request body",
254 [SMP_SRC_BKEND] = "backend",
255 [SMP_SRC_SERVR] = "server",
256 [SMP_SRC_L4SRV] = "server address",
257 [SMP_SRC_L5SRV] = "server-side connection",
258 [SMP_SRC_L6RES] = "response buffer",
259 [SMP_SRC_HRSHV] = "HTTP response headers",
260 [SMP_SRC_HRSHP] = "HTTP response",
261 [SMP_SRC_HRSBO] = "HTTP response body",
262 [SMP_SRC_RQFIN] = "request buffer statistics",
263 [SMP_SRC_RSFIN] = "response buffer statistics",
264 [SMP_SRC_TXFIN] = "transaction statistics",
265 [SMP_SRC_SSFIN] = "session statistics",
266};
267
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100268static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
269 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
270 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
271 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
272 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
273 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
274 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
275 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
276 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
277 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
278 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
279 [SMP_CKP_BE_SRV_CON] = "server source selection",
280 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
281 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
282 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
283 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
284 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
285 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
286 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
287 [SMP_CKP_FE_LOG_END] = "logs",
288};
289
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100290/* This function returns the type of the data returned by the sample_expr.
291 * It assumes that the <expr> and all of its converters are properly
292 * initialized.
293 */
294inline
295int smp_expr_output_type(struct sample_expr *expr)
296{
297 struct sample_conv_expr *smp_expr;
298
299 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
300 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
301 return smp_expr->conv->out_type;
302 }
303 return expr->fetch->out_type;
304}
305
306
Willy Tarreau80aca902013-01-07 15:42:20 +0100307/* fill the trash with a comma-delimited list of source names for the <use> bit
308 * field which must be composed of a non-null set of SMP_USE_* flags. The return
309 * value is the pointer to the string in the trash buffer.
310 */
311const char *sample_src_names(unsigned int use)
312{
313 int bit;
314
315 trash.len = 0;
316 trash.str[0] = '\0';
317 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
318 if (!(use & ~((1 << bit) - 1)))
319 break; /* no more bits */
320
321 if (!(use & (1 << bit)))
322 continue; /* bit not set */
323
324 trash.len += snprintf(trash.str + trash.len, trash.size - trash.len, "%s%s",
325 (use & ((1 << bit) - 1)) ? "," : "",
326 fetch_src_names[bit]);
327 }
328 return trash.str;
329}
330
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100331/* return a pointer to the correct sample checkpoint name, or "unknown" when
332 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
333 * if set.
334 */
335const char *sample_ckp_names(unsigned int use)
336{
337 int bit;
338
339 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
340 if (use & (1 << bit))
341 return fetch_ckp_names[bit];
342 return "unknown sample check place, please report this bug";
343}
344
Emeric Brun107ca302010-01-04 16:16:05 +0100345/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100346 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
347 * for next parsing sessions. The fetch keywords capabilities are also computed
348 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100349 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100350void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100351{
Willy Tarreau80aca902013-01-07 15:42:20 +0100352 struct sample_fetch *sf;
353 int bit;
354
355 for (sf = kwl->kw; sf->kw != NULL; sf++) {
356 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
357 if (sf->use & (1 << bit))
358 sf->val |= fetch_cap[bit];
359 }
360 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100361}
362
363/*
Willy Tarreau12785782012-04-27 21:37:17 +0200364 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100365 * parsing sessions.
366 */
Willy Tarreau12785782012-04-27 21:37:17 +0200367void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100368{
Willy Tarreau12785782012-04-27 21:37:17 +0200369 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100370}
371
372/*
Willy Tarreau12785782012-04-27 21:37:17 +0200373 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100374 * string of <len> in buffer <kw>.
375 *
376 */
Willy Tarreau12785782012-04-27 21:37:17 +0200377struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100378{
379 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200380 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100381
Willy Tarreau12785782012-04-27 21:37:17 +0200382 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100383 for (index = 0; kwl->kw[index].kw != NULL; index++) {
384 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
385 kwl->kw[index].kw[len] == '\0')
386 return &kwl->kw[index];
387 }
388 }
389 return NULL;
390}
391
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100392/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100393 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100394 * <idx> is the index of the next sample fetch entry. It is used as private
395 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100396 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100397 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100398 * the list is reached.
399 */
400struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
401{
402 struct sample_fetch_kw_list *kwl;
403 struct sample_fetch *base;
404
405 if (!current) {
406 /* Get first kwl entry. */
407 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
408 (*idx) = 0;
409 } else {
410 /* Get kwl corresponding to the curret entry. */
411 base = current + 1 - (*idx);
412 kwl = container_of(base, struct sample_fetch_kw_list, kw);
413 }
414
415 while (1) {
416
417 /* Check if kwl is the last entry. */
418 if (&kwl->list == &sample_fetches.list)
419 return NULL;
420
421 /* idx contain the next keyword. If it is available, return it. */
422 if (kwl->kw[*idx].kw) {
423 (*idx)++;
424 return &kwl->kw[(*idx)-1];
425 }
426
427 /* get next entry in the main list, and return NULL if the end is reached. */
428 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
429
430 /* Set index to 0, ans do one other loop. */
431 (*idx) = 0;
432 }
433}
434
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100435/* This function browses the list of available converters. <current> is
436 * the last used converter. If it is the first call, it must set to NULL.
437 * <idx> is the index of the next converter entry. It is used as private
438 * value. It is useless to initiate it.
439 *
440 * It returns always the next sample_conv entry, and NULL when the end of
441 * the list is reached.
442 */
443struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
444{
445 struct sample_conv_kw_list *kwl;
446 struct sample_conv *base;
447
448 if (!current) {
449 /* Get first kwl entry. */
450 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
451 (*idx) = 0;
452 } else {
453 /* Get kwl corresponding to the curret entry. */
454 base = current + 1 - (*idx);
455 kwl = container_of(base, struct sample_conv_kw_list, kw);
456 }
457
458 while (1) {
459 /* Check if kwl is the last entry. */
460 if (&kwl->list == &sample_convs.list)
461 return NULL;
462
463 /* idx contain the next keyword. If it is available, return it. */
464 if (kwl->kw[*idx].kw) {
465 (*idx)++;
466 return &kwl->kw[(*idx)-1];
467 }
468
469 /* get next entry in the main list, and return NULL if the end is reached. */
470 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
471
472 /* Set index to 0, ans do one other loop. */
473 (*idx) = 0;
474 }
475}
476
Emeric Brun107ca302010-01-04 16:16:05 +0100477/*
Willy Tarreau12785782012-04-27 21:37:17 +0200478 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100479 * string of <len> in buffer <kw>.
480 *
481 */
Willy Tarreau12785782012-04-27 21:37:17 +0200482struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100483{
484 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200485 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100486
Willy Tarreau12785782012-04-27 21:37:17 +0200487 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100488 for (index = 0; kwl->kw[index].kw != NULL; index++) {
489 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
490 kwl->kw[index].kw[len] == '\0')
491 return &kwl->kw[index];
492 }
493 }
494 return NULL;
495}
496
Emeric Brun107ca302010-01-04 16:16:05 +0100497/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200498/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100499/******************************************************************/
500
Willy Tarreau342acb42012-04-23 22:03:39 +0200501static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100502{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200503 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200504 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100505 return 1;
506}
507
Willy Tarreau342acb42012-04-23 22:03:39 +0200508static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100509{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100510 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100511
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200512 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->str, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100513 return 0;
514
515 trash->len = strlen(trash->str);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200516 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200517 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100518 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100519
520 return 1;
521}
522
Willy Tarreau342acb42012-04-23 22:03:39 +0200523static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100524{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200525 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200526 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100527 return 1;
528}
529
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200530static int c_ipv62ip(struct sample *smp)
531{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200532 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200533 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100534 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200535 return 1;
536}
537
Willy Tarreau342acb42012-04-23 22:03:39 +0200538static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100539{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100540 struct chunk *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100541
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200542 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->str, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100543 return 0;
544
545 trash->len = strlen(trash->str);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200546 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200547 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100548 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100549 return 1;
550}
551
552/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200553static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100554{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200555 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100556}
557*/
558
Willy Tarreau342acb42012-04-23 22:03:39 +0200559static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100560{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200561 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200562 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100563 return 1;
564}
565
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200566static int c_int2ipv6(struct sample *smp)
567{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200568 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
569 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200570 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200571 return 1;
572}
573
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100574static int c_str2addr(struct sample *smp)
575{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200576 if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv4)) {
577 if (!buf2ip6(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100578 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200579 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100580 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100581 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100582 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200583 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100584 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100585 return 1;
586}
587
Willy Tarreau342acb42012-04-23 22:03:39 +0200588static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100589{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200590 if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100591 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200592 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100593 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100594 return 1;
595}
596
Willy Tarreau342acb42012-04-23 22:03:39 +0200597static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100598{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200599 if (!buf2ip6(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100600 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200601 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100602 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100603 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100604}
605
Emeric Brun4b9e8022014-11-03 18:17:10 +0100606/*
607 * The NULL char always enforces the end of string if it is met.
608 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100609 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200610static int c_bin2str(struct sample *smp)
611{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100612 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200613
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200614 for (i = 0; i < smp->data.u.str.len; i++) {
615 if (!smp->data.u.str.str[i]) {
616 smp->data.u.str.len = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100617 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100618 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200619 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200620 return 1;
621}
622
Willy Tarreau342acb42012-04-23 22:03:39 +0200623static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100624{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100625 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100626 char *pos;
627
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200628 pos = lltoa_r(smp->data.u.sint, trash->str, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100629 if (!pos)
630 return 0;
631
Emeric Brun485479d2010-09-23 18:02:19 +0200632 trash->size = trash->size - (pos - trash->str);
Emeric Brun107ca302010-01-04 16:16:05 +0100633 trash->str = pos;
634 trash->len = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200635 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200636 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100637 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100638 return 1;
639}
640
Willy Tarreauad635822016-08-08 19:21:09 +0200641/* This function inconditionally duplicates data and removes the "const" flag.
642 * For strings and binary blocks, it also provides a known allocated size with
643 * a length that is capped to the size, and ensures a trailing zero is always
644 * appended for strings. This is necessary for some operations which may
645 * require to extend the length. It returns 0 if it fails, 1 on success.
646 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100647int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200648{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100649 struct chunk *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200650
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;
Willy Tarreauad635822016-08-08 19:21:09 +0200659
Christopher Fauletec100512017-07-24 15:38:41 +0200660 case SMP_T_METH:
661 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
662 break;
663 /* Fall through */
664
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100665 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200666 trash = get_trash_chunk();
667 trash->len = smp->data.u.str.len;
668 if (trash->len > trash->size - 1)
669 trash->len = trash->size - 1;
670
671 memcpy(trash->str, smp->data.u.str.str, trash->len);
672 trash->str[trash->len] = 0;
673 smp->data.u.str = *trash;
674 break;
675
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100676 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100677 trash = get_trash_chunk();
Willy Tarreauad635822016-08-08 19:21:09 +0200678 trash->len = smp->data.u.str.len;
679 if (trash->len > trash->size)
680 trash->len = trash->size;
681
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200682 memcpy(trash->str, smp->data.u.str.str, trash->len);
683 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100684 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200685
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100686 default:
687 /* Other cases are unexpected. */
688 return 0;
689 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100690
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100691 /* remove const flag */
692 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200693 return 1;
694}
695
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100696int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100697{
698 return 1;
699}
700
Willy Tarreau342acb42012-04-23 22:03:39 +0200701static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100702{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200703 const char *str;
704 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100705
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200706 if (smp->data.u.str.len == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100707 return 0;
708
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200709 str = smp->data.u.str.str;
710 end = smp->data.u.str.str + smp->data.u.str.len;
Emeric Brun107ca302010-01-04 16:16:05 +0100711
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200712 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200713 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100714 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100715 return 1;
716}
717
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100718static int c_str2meth(struct sample *smp)
719{
720 enum http_meth_t meth;
721 int len;
722
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200723 meth = find_http_meth(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100724 if (meth == HTTP_METH_OTHER) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200725 len = smp->data.u.str.len;
726 smp->data.u.meth.str.str = smp->data.u.str.str;
727 smp->data.u.meth.str.len = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100728 }
729 else
730 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200731 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200732 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100733 return 1;
734}
735
736static int c_meth2str(struct sample *smp)
737{
738 int len;
739 enum http_meth_t meth;
740
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200741 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100742 /* The method is unknown. Copy the original pointer. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200743 len = smp->data.u.meth.str.len;
744 smp->data.u.str.str = smp->data.u.meth.str.str;
745 smp->data.u.str.len = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200746 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100747 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200748 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100749 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200750 meth = smp->data.u.meth.meth;
751 smp->data.u.str.str = http_known_methods[meth].name;
752 smp->data.u.str.len = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100753 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200754 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100755 }
756 else {
757 /* Unknown method */
758 return 0;
759 }
760 return 1;
761}
762
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200763static int c_addr2bin(struct sample *smp)
764{
765 struct chunk *chk = get_trash_chunk();
766
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200767 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200768 chk->len = 4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200769 memcpy(chk->str, &smp->data.u.ipv4, chk->len);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200770 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200771 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200772 chk->len = 16;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200773 memcpy(chk->str, &smp->data.u.ipv6, chk->len);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200774 }
775 else
776 return 0;
777
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200778 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200779 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200780 return 1;
781}
782
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200783static int c_int2bin(struct sample *smp)
784{
785 struct chunk *chk = get_trash_chunk();
786
Willy Tarreau5f6e9052016-05-20 06:29:59 +0200787 *(unsigned long long int *)chk->str = my_htonll(smp->data.u.sint);
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200788 chk->len = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200789
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200790 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200791 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200792 return 1;
793}
794
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200795
Emeric Brun107ca302010-01-04 16:16:05 +0100796/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200797/* Sample casts matrix: */
798/* sample_casts[from type][to type] */
799/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100800/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100801
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100802sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200803/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
804/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
805/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200806/* 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 +0200807/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
808/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200809/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200810/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
811/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
812/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200813};
Emeric Brun107ca302010-01-04 16:16:05 +0100814
Emeric Brun107ca302010-01-04 16:16:05 +0100815/*
Willy Tarreau12785782012-04-27 21:37:17 +0200816 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100817 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200818 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200819 * The caller must have set al->ctx.
Emeric Brun107ca302010-01-04 16:16:05 +0100820 */
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100821struct 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 +0100822{
Willy Tarreau833cc792013-07-24 15:34:19 +0200823 const char *begw; /* beginning of word */
824 const char *endw; /* end of word */
825 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200826 struct sample_expr *expr;
827 struct sample_fetch *fetch;
828 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100829 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200830 char *fkw = NULL;
831 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100832 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100833
Willy Tarreau833cc792013-07-24 15:34:19 +0200834 begw = str[*idx];
835 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
836
837 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100838 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100839 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200840 }
Emeric Brun107ca302010-01-04 16:16:05 +0100841
Willy Tarreau833cc792013-07-24 15:34:19 +0200842 /* keep a copy of the current fetch keyword for error reporting */
843 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100844
Willy Tarreau833cc792013-07-24 15:34:19 +0200845 fetch = find_sample_fetch(begw, endw - begw);
846 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100847 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100848 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200849 }
Emeric Brun107ca302010-01-04 16:16:05 +0100850
Willy Tarreau833cc792013-07-24 15:34:19 +0200851 endt = endw;
852 if (*endt == '(') {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100853 /* look for the end of this term and skip the opening parenthesis */
854 endt = ++endw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200855 while (*endt && *endt != ')')
856 endt++;
857 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100858 memprintf(err_msg, "missing closing ')' after arguments to fetch keyword '%s'", fkw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200859 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200860 }
Emeric Brun485479d2010-09-23 18:02:19 +0200861 }
Emeric Brun107ca302010-01-04 16:16:05 +0100862
Willy Tarreau833cc792013-07-24 15:34:19 +0200863 /* At this point, we have :
864 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100865 * - endw : end of the keyword, first character not part of keyword
866 * nor the opening parenthesis (so first character of args
867 * if present).
Willy Tarreau833cc792013-07-24 15:34:19 +0200868 * - endt : end of the term (=endw or last parenthesis if args are present)
869 */
870
871 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100872 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100873 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200874 }
Emeric Brun107ca302010-01-04 16:16:05 +0100875 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200876
Vincent Bernat02779b62016-04-03 13:48:43 +0200877 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200878 if (!expr)
879 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100880
881 LIST_INIT(&(expr->conv_exprs));
882 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200883 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100884
Willy Tarreau689a1df2013-12-13 00:40:11 +0100885 /* Note that we call the argument parser even with an empty string,
886 * this allows it to automatically create entries for mandatory
887 * implicit arguments (eg: local proxy name).
888 */
889 al->kw = expr->fetch->kw;
890 al->conv = NULL;
891 if (make_arg_list(endw, endt - endw, fetch->arg_mask, &expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
892 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
893 goto out_error;
894 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200895
Willy Tarreau689a1df2013-12-13 00:40:11 +0100896 if (!expr->arg_p) {
897 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200898 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100899 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
900 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200901 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100902 }
903
Willy Tarreau833cc792013-07-24 15:34:19 +0200904 /* Now process the converters if any. We have two supported syntaxes
905 * for the converters, which can be combined :
906 * - comma-delimited list of converters just after the keyword and args ;
907 * - one converter per keyword
908 * The combination allows to have each keyword being a comma-delimited
909 * series of converters.
910 *
911 * We want to process the former first, then the latter. For this we start
912 * from the beginning of the supposed place in the exiting conv chain, which
913 * starts at the last comma (endt).
914 */
915
916 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200917 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100918
Willy Tarreau833cc792013-07-24 15:34:19 +0200919 if (*endt == ')') /* skip last closing parenthesis */
920 endt++;
Emeric Brun107ca302010-01-04 16:16:05 +0100921
Willy Tarreau833cc792013-07-24 15:34:19 +0200922 if (*endt && *endt != ',') {
923 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100924 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200925 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100926 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100927 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200928 }
Emeric Brun107ca302010-01-04 16:16:05 +0100929
Willy Tarreau833cc792013-07-24 15:34:19 +0200930 while (*endt == ',') /* then trailing commas */
931 endt++;
932
Willy Tarreau97108e02016-11-25 07:33:24 +0100933 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200934
935 if (!*begw) {
936 /* none ? skip to next string */
937 (*idx)++;
938 begw = str[*idx];
939 if (!begw || !*begw)
940 break;
941 }
942
943 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
944
945 free(ckw);
946 ckw = my_strndup(begw, endw - begw);
947
948 conv = find_sample_conv(begw, endw - begw);
949 if (!conv) {
950 /* we found an isolated keyword that we don't know, it's not ours */
951 if (begw == str[*idx])
952 break;
Willy Tarreau97108e02016-11-25 07:33:24 +0100953 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200954 goto out_error;
955 }
Emeric Brun107ca302010-01-04 16:16:05 +0100956
Willy Tarreau833cc792013-07-24 15:34:19 +0200957 endt = endw;
958 if (*endt == '(') {
959 /* look for the end of this term */
960 while (*endt && *endt != ')')
961 endt++;
962 if (*endt != ')') {
Willy Tarreau97108e02016-11-25 07:33:24 +0100963 memprintf(err_msg, "syntax error: missing ')' after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200964 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200965 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200966 }
967
968 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100969 memprintf(err_msg, "returns type of converter '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100970 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200971 }
Emeric Brun107ca302010-01-04 16:16:05 +0100972
973 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200974 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100975 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100976 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200977 }
Emeric Brun107ca302010-01-04 16:16:05 +0100978
979 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +0200980 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200981 if (!conv_expr)
982 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100983
984 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
985 conv_expr->conv = conv;
986
Willy Tarreau833cc792013-07-24 15:34:19 +0200987 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200988 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200989
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200990 if (!conv->arg_mask) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100991 memprintf(err_msg, "converter '%s' does not support any args", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200992 goto out_error;
993 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100994
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200995 al->kw = expr->fetch->kw;
996 al->conv = conv_expr->conv->kw;
Willy Tarreau975c1782013-12-12 23:16:54 +0100997 if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100998 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200999 goto out_error;
1000 }
1001
Willy Tarreau2e845be2012-10-19 19:49:09 +02001002 if (!conv_expr->arg_p)
1003 conv_expr->arg_p = empty_arg_list;
1004
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +01001005 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
Willy Tarreau97108e02016-11-25 07:33:24 +01001006 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001007 goto out_error;
1008 }
1009 }
Willy Tarreau833cc792013-07-24 15:34:19 +02001010 else if (ARGM(conv->arg_mask)) {
Willy Tarreau97108e02016-11-25 07:33:24 +01001011 memprintf(err_msg, "missing args for converter '%s'", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +02001012 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001013 }
1014 }
Emeric Brun485479d2010-09-23 18:02:19 +02001015
Willy Tarreau833cc792013-07-24 15:34:19 +02001016 out:
1017 free(fkw);
1018 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001019 return expr;
1020
1021out_error:
Willy Tarreau12785782012-04-27 21:37:17 +02001022 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +02001023 expr = NULL;
1024 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001025}
1026
1027/*
Willy Tarreau12785782012-04-27 21:37:17 +02001028 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001029 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001030 * Returns a pointer on a typed sample structure containing the result or NULL if
1031 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001032 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001033 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001034 *
1035 * Note: the fetch functions are required to properly set the return type. The
1036 * conversion functions must do so too. However the cast functions do not need
1037 * to since they're made to cast mutiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001038 *
1039 * The caller may indicate in <opt> if it considers the result final or not.
1040 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1041 * if the result is stable or not, according to the following table :
1042 *
1043 * return MAY_CHANGE FINAL Meaning for the sample
1044 * NULL 0 * Not present and will never be (eg: header)
1045 * NULL 1 0 Not present yet, could change (eg: POST param)
1046 * NULL 1 1 Not present yet, will not change anymore
1047 * smp 0 * Present and will not change (eg: header)
1048 * smp 1 0 Present, may change (eg: request length)
1049 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001050 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001051struct sample *sample_process(struct proxy *px, struct session *sess,
1052 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001053 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001054{
Willy Tarreau12785782012-04-27 21:37:17 +02001055 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001056
Willy Tarreau18387e22013-07-25 12:02:38 +02001057 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001058 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001059 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001060 }
Emeric Brun107ca302010-01-04 16:16:05 +01001061
Willy Tarreau1777ea62016-03-10 16:15:46 +01001062 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001063 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001064 return NULL;
1065
Emeric Brun107ca302010-01-04 16:16:05 +01001066 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001067 /* we want to ensure that p->type can be casted into
1068 * conv_expr->conv->in_type. We have 3 possibilities :
1069 * - NULL => not castable.
1070 * - c_none => nothing to do (let's optimize it)
1071 * - other => apply cast and prepare to fail
1072 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001073 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001074 return NULL;
1075
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001076 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1077 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001078 return NULL;
1079
Willy Tarreau12e50112012-04-25 17:21:49 +02001080 /* OK cast succeeded */
1081
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001082 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001083 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001084 }
1085 return p;
1086}
1087
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001088/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001089 * Resolve all remaining arguments in proxy <p>. Returns the number of
1090 * errors or 0 if everything is fine.
1091 */
1092int smp_resolve_args(struct proxy *p)
1093{
1094 struct arg_list *cur, *bak;
1095 const char *ctx, *where;
1096 const char *conv_ctx, *conv_pre, *conv_pos;
1097 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001098 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001099 struct arg *arg;
1100 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001101 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001102
1103 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1104 struct proxy *px;
1105 struct server *srv;
1106 char *pname, *sname;
Willy Tarreau46947782015-01-19 19:00:58 +01001107 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001108
1109 arg = cur->arg;
1110
1111 /* prepare output messages */
1112 conv_pre = conv_pos = conv_ctx = "";
1113 if (cur->conv) {
1114 conv_ctx = cur->conv;
1115 conv_pre = "conversion keyword '";
1116 conv_pos = "' for ";
1117 }
1118
1119 where = "in";
1120 ctx = "sample fetch keyword";
1121 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001122 case ARGC_STK: where = "in stick rule in"; break;
1123 case ARGC_TRK: where = "in tracking rule in"; break;
1124 case ARGC_LOG: where = "in log-format string in"; break;
1125 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1126 case ARGC_HRQ: where = "in http-request header format string in"; break;
1127 case ARGC_HRS: where = "in http-response header format string in"; break;
1128 case ARGC_UIF: where = "in unique-id-format string in"; break;
1129 case ARGC_RDR: where = "in redirect format string in"; break;
1130 case ARGC_CAP: where = "in capture rule in"; break;
1131 case ARGC_ACL: ctx = "ACL keyword"; break;
1132 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001133 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001134 }
1135
1136 /* set a few default settings */
1137 px = p;
1138 pname = p->id;
1139
1140 switch (arg->type) {
1141 case ARGT_SRV:
1142 if (!arg->data.str.len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001143 ha_alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1144 cur->file, cur->line,
1145 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001146 cfgerr++;
1147 continue;
1148 }
1149
1150 /* we support two formats : "bck/srv" and "srv" */
1151 sname = strrchr(arg->data.str.str, '/');
1152
1153 if (sname) {
1154 *sname++ = '\0';
1155 pname = arg->data.str.str;
1156
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001157 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001158 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001159 ha_alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1160 cur->file, cur->line, pname,
1161 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001162 cfgerr++;
1163 break;
1164 }
1165 }
1166 else
1167 sname = arg->data.str.str;
1168
1169 srv = findserver(px, sname);
1170 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001171 ha_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",
1172 cur->file, cur->line, sname, pname,
1173 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001174 cfgerr++;
1175 break;
1176 }
1177
1178 free(arg->data.str.str);
1179 arg->data.str.str = NULL;
1180 arg->unresolved = 0;
1181 arg->data.srv = srv;
1182 break;
1183
1184 case ARGT_FE:
1185 if (arg->data.str.len) {
1186 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001187 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001188 }
1189
1190 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001191 ha_alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1192 cur->file, cur->line, pname,
1193 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001194 cfgerr++;
1195 break;
1196 }
1197
1198 if (!(px->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001199 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1200 cur->file, cur->line, pname,
1201 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001202 cfgerr++;
1203 break;
1204 }
1205
1206 free(arg->data.str.str);
1207 arg->data.str.str = NULL;
1208 arg->unresolved = 0;
1209 arg->data.prx = px;
1210 break;
1211
1212 case ARGT_BE:
1213 if (arg->data.str.len) {
1214 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001215 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001216 }
1217
1218 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001219 ha_alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1220 cur->file, cur->line, pname,
1221 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001222 cfgerr++;
1223 break;
1224 }
1225
1226 if (!(px->cap & PR_CAP_BE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001227 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1228 cur->file, cur->line, pname,
1229 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001230 cfgerr++;
1231 break;
1232 }
1233
1234 free(arg->data.str.str);
1235 arg->data.str.str = NULL;
1236 arg->unresolved = 0;
1237 arg->data.prx = px;
1238 break;
1239
1240 case ARGT_TAB:
1241 if (arg->data.str.len) {
1242 pname = arg->data.str.str;
Willy Tarreaue2dc1fa2015-05-26 12:08:07 +02001243 px = proxy_tbl_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001244 }
1245
1246 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001247 ha_alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1248 cur->file, cur->line, pname,
1249 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001250 cfgerr++;
1251 break;
1252 }
1253
1254 if (!px->table.size) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001255 ha_alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1256 cur->file, cur->line, pname,
1257 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001258 cfgerr++;
1259 break;
1260 }
1261
1262 free(arg->data.str.str);
1263 arg->data.str.str = NULL;
1264 arg->unresolved = 0;
1265 arg->data.prx = px;
1266 break;
1267
1268 case ARGT_USR:
1269 if (!arg->data.str.len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001270 ha_alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1271 cur->file, cur->line,
1272 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001273 cfgerr++;
1274 break;
1275 }
1276
1277 if (p->uri_auth && p->uri_auth->userlist &&
1278 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1279 ul = p->uri_auth->userlist;
1280 else
1281 ul = auth_find_userlist(arg->data.str.str);
1282
1283 if (!ul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001284 ha_alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1285 cur->file, cur->line, arg->data.str.str,
1286 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001287 cfgerr++;
1288 break;
1289 }
1290
1291 free(arg->data.str.str);
1292 arg->data.str.str = NULL;
1293 arg->unresolved = 0;
1294 arg->data.usr = ul;
1295 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001296
1297 case ARGT_REG:
1298 if (!arg->data.str.len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001299 ha_alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1300 cur->file, cur->line,
1301 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001302 cfgerr++;
1303 continue;
1304 }
1305
1306 reg = calloc(1, sizeof(*reg));
1307 if (!reg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001308 ha_alert("parsing [%s:%d] : not enough memory to build regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1309 cur->file, cur->line,
1310 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001311 cfgerr++;
1312 continue;
1313 }
1314
1315 rflags = 0;
1316 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1317 err = NULL;
1318
Willy Tarreaud817e462015-01-23 20:23:17 +01001319 if (!regex_comp(arg->data.str.str, reg, !(rflags & REG_ICASE), 1 /* capture substr */, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001320 ha_alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1321 cur->file, cur->line,
1322 arg->data.str.str,
1323 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
Willy Tarreau46947782015-01-19 19:00:58 +01001324 cfgerr++;
1325 continue;
1326 }
1327
1328 free(arg->data.str.str);
1329 arg->data.str.str = NULL;
1330 arg->unresolved = 0;
1331 arg->data.reg = reg;
1332 break;
1333
1334
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001335 }
1336
1337 LIST_DEL(&cur->list);
1338 free(cur);
1339 } /* end of args processing */
1340
1341 return cfgerr;
1342}
1343
1344/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001345 * Process a fetch + format conversion as defined by the sample expression
1346 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001347 * not explicitly set to <smp_type>, but shall be compatible with it as
1348 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1349 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001350 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1351 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1352 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1353 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001354 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1355 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1356 * still hope to get it after waiting longer, and is not converted to string.
1357 * The possible output combinations are the following :
1358 *
1359 * return MAY_CHANGE FINAL Meaning for the sample
1360 * NULL * * Not present and will never be (eg: header)
1361 * smp 0 * Final value converted (eg: header)
1362 * smp 1 0 Not present yet, may appear later (eg: header)
1363 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001364 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001365struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001366 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001367 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001368{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001369 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001370
Willy Tarreau6c616e02014-06-25 16:56:41 +02001371 memset(smp, 0, sizeof(*smp));
1372
Willy Tarreau192252e2015-04-04 01:47:55 +02001373 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001374 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1375 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001376 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001377 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001378
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001379 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001380 return NULL;
1381
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001382 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001383 return NULL;
1384
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001385 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001386 return smp;
1387}
1388
Christopher Faulet476e5d02016-10-26 11:34:47 +02001389static void release_sample_arg(struct arg *p)
1390{
1391 struct arg *p_back = p;
1392
1393 if (!p)
1394 return;
1395
1396 while (p->type != ARGT_STOP) {
1397 if (p->type == ARGT_STR || p->unresolved) {
1398 free(p->data.str.str);
1399 p->data.str.str = NULL;
1400 p->unresolved = 0;
1401 }
1402 else if (p->type == ARGT_REG) {
1403 if (p->data.reg) {
1404 regex_free(p->data.reg);
1405 free(p->data.reg);
1406 p->data.reg = NULL;
1407 }
1408 }
1409 p++;
1410 }
1411
1412 if (p_back != empty_arg_list)
1413 free(p_back);
1414}
1415
1416void release_sample_expr(struct sample_expr *expr)
1417{
1418 struct sample_conv_expr *conv_expr, *conv_exprb;
1419
1420 if (!expr)
1421 return;
1422
1423 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list)
1424 release_sample_arg(conv_expr->arg_p);
1425 release_sample_arg(expr->arg_p);
1426 free(expr);
1427}
1428
Emeric Brun107ca302010-01-04 16:16:05 +01001429/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001430/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001431/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001432/*****************************************************************/
1433
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001434#ifdef DEBUG_EXPR
1435static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1436{
1437 int i;
1438 struct sample tmp;
1439
1440 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001441 fprintf(stderr, "[debug converter] type: %s ", smp_to_type[smp->data.type]);
1442 if (!sample_casts[smp->data.type][SMP_T_STR]) {
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001443 fprintf(stderr, "(undisplayable)");
1444 } else {
1445
1446 /* Copy sample fetch. This put the sample as const, the
1447 * cast will copy data if a transformation is required.
1448 */
1449 memcpy(&tmp, smp, sizeof(struct sample));
1450 tmp.flags = SMP_F_CONST;
1451
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001452 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001453 fprintf(stderr, "(undisplayable)");
1454
1455 else {
1456 /* Display the displayable chars*. */
1457 fprintf(stderr, "<");
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001458 for (i = 0; i < tmp.data.u.str.len; i++) {
1459 if (isprint(tmp.data.u.str.str[i]))
1460 fputc(tmp.data.u.str.str[i], stderr);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001461 else
1462 fputc('.', stderr);
1463 }
1464 }
1465 fprintf(stderr, ">\n");
1466 }
1467 }
1468 return 1;
1469}
1470#endif
1471
Holger Just1bfc24b2017-05-06 00:56:53 +02001472static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1473{
1474 struct chunk *trash = get_trash_chunk();
1475 int bin_len;
1476
1477 trash->len = 0;
1478 bin_len = base64dec(smp->data.u.str.str, smp->data.u.str.len, trash->str, trash->size);
1479 if (bin_len < 0)
1480 return 0;
1481
1482 trash->len = bin_len;
1483 smp->data.u.str = *trash;
1484 smp->data.type = SMP_T_BIN;
1485 smp->flags &= ~SMP_F_CONST;
1486 return 1;
1487}
1488
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001489static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001490{
1491 struct chunk *trash = get_trash_chunk();
1492 int b64_len;
1493
1494 trash->len = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001495 b64_len = a2base64(smp->data.u.str.str, smp->data.u.str.len, trash->str, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001496 if (b64_len < 0)
1497 return 0;
1498
1499 trash->len = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001500 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001501 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001502 smp->flags &= ~SMP_F_CONST;
1503 return 1;
1504}
1505
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001506static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1507{
1508 blk_SHA_CTX ctx;
1509 struct chunk *trash = get_trash_chunk();
1510
1511 memset(&ctx, 0, sizeof(ctx));
1512
1513 blk_SHA1_Init(&ctx);
1514 blk_SHA1_Update(&ctx, smp->data.u.str.str, smp->data.u.str.len);
1515 blk_SHA1_Final((unsigned char *)trash->str, &ctx);
1516
1517 trash->len = 20;
1518 smp->data.u.str = *trash;
1519 smp->data.type = SMP_T_BIN;
1520 smp->flags &= ~SMP_F_CONST;
1521 return 1;
1522}
1523
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001524static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001525{
1526 struct chunk *trash = get_trash_chunk();
1527 unsigned char c;
1528 int ptr = 0;
1529
1530 trash->len = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001531 while (ptr < smp->data.u.str.len && trash->len <= trash->size - 2) {
1532 c = smp->data.u.str.str[ptr++];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001533 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
1534 trash->str[trash->len++] = hextab[c & 0xF];
1535 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001536 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001537 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001538 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001539 return 1;
1540}
1541
Dragan Dosen3f957b22017-10-24 09:27:34 +02001542static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
1543{
1544 long long int n = 0;
1545 int i, c;
1546
1547 for (i = 0; i < smp->data.u.str.len; i++) {
1548 if ((c = hex2i(smp->data.u.str.str[i])) < 0)
1549 return 0;
1550 n = (n << 4) + c;
1551 }
1552
1553 smp->data.u.sint = n;
1554 smp->data.type = SMP_T_SINT;
1555 smp->flags &= ~SMP_F_CONST;
1556 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_djb2(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_djb2(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 Tarreau60a2ee72017-12-15 07:13:48 +01001569static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001570{
1571 int i = smp->data.u.str.len;
1572 smp->data.u.sint = i;
1573 smp->data.type = SMP_T_SINT;
1574 return 1;
1575}
1576
1577
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001578static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001579{
1580 int i;
1581
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001582 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001583 return 0;
1584
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001585 for (i = 0; i < smp->data.u.str.len; i++) {
1586 if ((smp->data.u.str.str[i] >= 'A') && (smp->data.u.str.str[i] <= 'Z'))
1587 smp->data.u.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001588 }
1589 return 1;
1590}
1591
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001592static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001593{
1594 int i;
1595
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001596 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02001597 return 0;
1598
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001599 for (i = 0; i < smp->data.u.str.len; i++) {
1600 if ((smp->data.u.str.str[i] >= 'a') && (smp->data.u.str.str[i] <= 'z'))
1601 smp->data.u.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001602 }
1603 return 1;
1604}
1605
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001606/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
1607static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001608{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001609 /* Attempt to convert to IPv4 to apply the correct mask. */
1610 c_ipv62ip(smp);
1611
1612 if (smp->data.type == SMP_T_IPV4) {
1613 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
1614 smp->data.type = SMP_T_IPV4;
1615 }
1616 else if (smp->data.type == SMP_T_IPV6) {
1617 /* IPv6 cannot be converted without an IPv6 mask. */
1618 if (args[1].type != ARGT_IPV6)
1619 return 0;
1620
1621 *(uint32_t*)&smp->data.u.ipv6.s6_addr[0] &= *(uint32_t*)&args[1].data.ipv6.s6_addr[0];
1622 *(uint32_t*)&smp->data.u.ipv6.s6_addr[4] &= *(uint32_t*)&args[1].data.ipv6.s6_addr[4];
1623 *(uint32_t*)&smp->data.u.ipv6.s6_addr[8] &= *(uint32_t*)&args[1].data.ipv6.s6_addr[8];
1624 *(uint32_t*)&smp->data.u.ipv6.s6_addr[12] &= *(uint32_t*)&args[1].data.ipv6.s6_addr[12];
1625 smp->data.type = SMP_T_IPV6;
1626 }
1627
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001628 return 1;
1629}
1630
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001631/* takes an UINT value on input supposed to represent the time since EPOCH,
1632 * adds an optional offset found in args[1] and emits a string representing
1633 * the local time in the format specified in args[1] using strftime().
1634 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001635static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001636{
1637 struct chunk *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001638 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001639 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001640 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001641
1642 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001643 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001644 curr_date += args[1].data.sint;
1645
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001646 tm = localtime(&curr_date);
1647 if (!tm)
1648 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001649 temp = get_trash_chunk();
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001650 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001651 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001652 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001653 return 1;
1654}
1655
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001656/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001657static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001658{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001659 smp->data.u.sint = hash_sdbm(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001660 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001661 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001662 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001663 return 1;
1664}
1665
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001666/* takes an UINT value on input supposed to represent the time since EPOCH,
1667 * adds an optional offset found in args[1] and emits a string representing
1668 * the UTC date in the format specified in args[1] using strftime().
1669 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001670static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001671{
1672 struct chunk *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001673 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001674 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001675 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001676
1677 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001678 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001679 curr_date += args[1].data.sint;
1680
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001681 tm = gmtime(&curr_date);
1682 if (!tm)
1683 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001684 temp = get_trash_chunk();
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001685 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001686 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001687 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001688 return 1;
1689}
1690
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001691/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001692static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001693{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001694 smp->data.u.sint = hash_wt6(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001695 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001696 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001697 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001698 return 1;
1699}
1700
Thierry FOURNIER01e09742016-12-26 11:46:11 +01001701/* hashes the binary input into a 32-bit unsigned int using xxh.
1702 * The seed of the hash defaults to 0 but can be changd in argument 1.
1703 */
1704static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
1705{
1706 unsigned int seed;
1707
1708 if (arg_p && arg_p->data.sint)
1709 seed = arg_p->data.sint;
1710 else
1711 seed = 0;
1712 smp->data.u.sint = XXH32(smp->data.u.str.str, smp->data.u.str.len, seed);
1713 smp->data.type = SMP_T_SINT;
1714 return 1;
1715}
1716
1717/* hashes the binary input into a 64-bit unsigned int using xxh.
1718 * In fact, the function returns a 64 bit unsigned, but the sample
1719 * storage of haproxy only proposes 64-bits signed, so the value is
1720 * cast as signed. This cast doesn't impact the hash repartition.
1721 * The seed of the hash defaults to 0 but can be changd in argument 1.
1722 */
1723static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
1724{
1725 unsigned long long int seed;
1726
1727 if (arg_p && arg_p->data.sint)
1728 seed = (unsigned long long int)arg_p->data.sint;
1729 else
1730 seed = 0;
1731 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.str, smp->data.u.str.len, seed);
1732 smp->data.type = SMP_T_SINT;
1733 return 1;
1734}
1735
Willy Tarreau80599772015-01-20 19:35:24 +01001736/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001737static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01001738{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001739 smp->data.u.sint = hash_crc32(smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001740 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001741 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001742 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01001743 return 1;
1744}
1745
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001746/* This function escape special json characters. The returned string can be
1747 * safely set between two '"' and used as json string. The json string is
1748 * defined like this:
1749 *
1750 * any Unicode character except '"' or '\' or control character
1751 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
1752 *
1753 * The enum input_type contain all the allowed mode for decoding the input
1754 * string.
1755 */
1756enum input_type {
1757 IT_ASCII = 0,
1758 IT_UTF8,
1759 IT_UTF8S,
1760 IT_UTF8P,
1761 IT_UTF8PS,
1762};
1763static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
1764 const char *file, int line, char **err)
1765{
1766 if (!arg) {
1767 memprintf(err, "Unexpected empty arg list");
1768 return 0;
1769 }
1770
1771 if (arg->type != ARGT_STR) {
1772 memprintf(err, "Unexpected arg type");
1773 return 0;
1774 }
1775
1776 if (strcmp(arg->data.str.str, "") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001777 arg->type = ARGT_SINT;
1778 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001779 return 1;
1780 }
1781
1782 else if (strcmp(arg->data.str.str, "ascii") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001783 arg->type = ARGT_SINT;
1784 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001785 return 1;
1786 }
1787
1788 else if (strcmp(arg->data.str.str, "utf8") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001789 arg->type = ARGT_SINT;
1790 arg->data.sint = IT_UTF8;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001791 return 1;
1792 }
1793
1794 else if (strcmp(arg->data.str.str, "utf8s") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001795 arg->type = ARGT_SINT;
1796 arg->data.sint = IT_UTF8S;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001797 return 1;
1798 }
1799
1800 else if (strcmp(arg->data.str.str, "utf8p") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001801 arg->type = ARGT_SINT;
1802 arg->data.sint = IT_UTF8P;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001803 return 1;
1804 }
1805
1806 else if (strcmp(arg->data.str.str, "utf8ps") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001807 arg->type = ARGT_SINT;
1808 arg->data.sint = IT_UTF8PS;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001809 return 1;
1810 }
1811
Thierry FOURNIER / OZON.IOa69c9122016-11-23 01:13:57 +01001812 memprintf(err, "Unexpected input code type. "
1813 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001814 return 0;
1815}
1816
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001817static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001818{
1819 struct chunk *temp;
1820 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
1821 const char *str;
1822 int len;
1823 enum input_type input_type = IT_ASCII;
1824 unsigned int c;
1825 unsigned int ret;
1826 char *p;
1827
1828 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001829 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001830
1831 temp = get_trash_chunk();
1832 temp->len = 0;
1833
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001834 p = smp->data.u.str.str;
1835 while (p < smp->data.u.str.str + smp->data.u.str.len) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001836
1837 if (input_type == IT_ASCII) {
1838 /* Read input as ASCII. */
1839 c = *(unsigned char *)p;
1840 p++;
1841 }
1842 else {
1843 /* Read input as UTF8. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001844 ret = utf8_next(p, smp->data.u.str.len - ( p - smp->data.u.str.str ), &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001845 p += utf8_return_length(ret);
1846
1847 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
1848 return 0;
1849 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
1850 continue;
1851 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1852 return 0;
1853 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1854 continue;
1855
1856 /* Check too big values. */
1857 if ((unsigned int)c > 0xffff) {
1858 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
1859 return 0;
1860 continue;
1861 }
1862 }
1863
1864 /* Convert character. */
1865 if (c == '"') {
1866 len = 2;
1867 str = "\\\"";
1868 }
1869 else if (c == '\\') {
1870 len = 2;
1871 str = "\\\\";
1872 }
1873 else if (c == '/') {
1874 len = 2;
1875 str = "\\/";
1876 }
1877 else if (c == '\b') {
1878 len = 2;
1879 str = "\\b";
1880 }
1881 else if (c == '\f') {
1882 len = 2;
1883 str = "\\f";
1884 }
1885 else if (c == '\r') {
1886 len = 2;
1887 str = "\\r";
1888 }
1889 else if (c == '\n') {
1890 len = 2;
1891 str = "\\n";
1892 }
1893 else if (c == '\t') {
1894 len = 2;
1895 str = "\\t";
1896 }
1897 else if (c > 0xff || !isprint(c)) {
1898 /* isprint generate a segfault if c is too big. The man says that
1899 * c must have the value of an unsigned char or EOF.
1900 */
1901 len = 6;
1902 _str[0] = '\\';
1903 _str[1] = 'u';
1904 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
1905 str = _str;
1906 }
1907 else {
1908 len = 1;
1909 str = (char *)&c;
1910 }
1911
1912 /* Check length */
1913 if (temp->len + len > temp->size)
1914 return 0;
1915
1916 /* Copy string. */
1917 memcpy(temp->str + temp->len, str, len);
1918 temp->len += len;
1919 }
1920
1921 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001922 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001923 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001924
1925 return 1;
1926}
1927
Emeric Brun54c4ac82014-11-03 15:32:43 +01001928/* This sample function is designed to extract some bytes from an input buffer.
1929 * First arg is the offset.
1930 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001931static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01001932{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001933 if (smp->data.u.str.len <= arg_p[0].data.sint) {
1934 smp->data.u.str.len = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001935 return 1;
1936 }
1937
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001938 if (smp->data.u.str.size)
1939 smp->data.u.str.size -= arg_p[0].data.sint;
1940 smp->data.u.str.len -= arg_p[0].data.sint;
1941 smp->data.u.str.str += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001942
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001943 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.len))
1944 smp->data.u.str.len = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01001945
1946 return 1;
1947}
1948
Emeric Brunf399b0d2014-11-03 17:07:03 +01001949static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
1950 const char *file, int line, char **err)
1951{
1952 struct arg *arg = args;
1953
1954 if (!arg) {
1955 memprintf(err, "Unexpected empty arg list");
1956 return 0;
1957 }
1958
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001959 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001960 memprintf(err, "Unexpected arg type");
1961 return 0;
1962 }
1963
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001964 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01001965 memprintf(err, "Unexpected value 0 for index");
1966 return 0;
1967 }
1968
1969 arg++;
1970
1971 if (arg->type != ARGT_STR) {
1972 memprintf(err, "Unexpected arg type");
1973 return 0;
1974 }
1975
1976 if (!arg->data.str.len) {
1977 memprintf(err, "Empty separators list");
1978 return 0;
1979 }
1980
1981 return 1;
1982}
1983
1984/* This sample function is designed to a return selected part of a string (field).
1985 * First arg is the index of the field (start at 1)
1986 * Second arg is a char list of separators (type string)
1987 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001988static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001989{
1990 unsigned int field;
1991 char *start, *end;
1992 int i;
1993
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001994 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001995 return 0;
1996
1997 field = 1;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001998 end = start = smp->data.u.str.str;
1999 while (end - smp->data.u.str.str < smp->data.u.str.len) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002000
2001 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
2002 if (*end == arg_p[1].data.str.str[i]) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002003 if (field == arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002004 goto found;
2005 start = end+1;
2006 field++;
2007 break;
2008 }
2009 }
2010 end++;
2011 }
2012
2013 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002014 if (field != arg_p[0].data.sint) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002015 smp->data.u.str.len = 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002016 return 1;
2017 }
2018found:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002019 smp->data.u.str.len = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002020 /* If ret string is len 0, no need to
2021 change pointers or to update size */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002022 if (!smp->data.u.str.len)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002023 return 1;
2024
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002025 smp->data.u.str.str = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002026
2027 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002028 Note: smp->data.u.str.size cannot be set to 0 */
2029 if (smp->data.u.str.size)
2030 smp->data.u.str.size -= start - smp->data.u.str.str;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002031
2032 return 1;
2033}
2034
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002035/* This sample function is designed to return a word from a string.
2036 * First arg is the index of the word (start at 1)
2037 * Second arg is a char list of words separators (type string)
2038 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002039static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002040{
2041 unsigned int word;
2042 char *start, *end;
2043 int i, issep, inword;
2044
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002045 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002046 return 0;
2047
2048 word = 0;
2049 inword = 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002050 end = start = smp->data.u.str.str;
2051 while (end - smp->data.u.str.str < smp->data.u.str.len) {
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002052 issep = 0;
2053 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
2054 if (*end == arg_p[1].data.str.str[i]) {
2055 issep = 1;
2056 break;
2057 }
2058 }
2059 if (!inword) {
2060 if (!issep) {
2061 word++;
2062 start = end;
2063 inword = 1;
2064 }
2065 }
2066 else if (issep) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002067 if (word == arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002068 goto found;
2069 inword = 0;
2070 }
2071 end++;
2072 }
2073
2074 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002075 if (word != arg_p[0].data.sint) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002076 smp->data.u.str.len = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002077 return 1;
2078 }
2079found:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002080 smp->data.u.str.len = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002081 /* If ret string is len 0, no need to
2082 change pointers or to update size */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002083 if (!smp->data.u.str.len)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002084 return 1;
2085
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002086 smp->data.u.str.str = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002087
2088 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002089 Note: smp->data.u.str.size cannot be set to 0 */
2090 if (smp->data.u.str.size)
2091 smp->data.u.str.size -= start - smp->data.u.str.str;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002092
2093 return 1;
2094}
2095
Willy Tarreau7eda8492015-01-20 19:47:06 +01002096static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2097 const char *file, int line, char **err)
2098{
2099 struct arg *arg = args;
2100 char *p;
2101 int len;
2102
2103 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2104 arg[0].type_flags = 0;
2105
2106 if (arg[2].type != ARGT_STR)
2107 return 1;
2108
2109 p = arg[2].data.str.str;
2110 len = arg[2].data.str.len;
2111 while (len) {
2112 if (*p == 'i') {
2113 arg[0].type_flags |= ARGF_REG_ICASE;
2114 }
2115 else if (*p == 'g') {
2116 arg[0].type_flags |= ARGF_REG_GLOB;
2117 }
2118 else {
2119 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2120 return 0;
2121 }
2122 p++;
2123 len--;
2124 }
2125 return 1;
2126}
2127
2128/* This sample function is designed to do the equivalent of s/match/replace/ on
2129 * the input string. It applies a regex and restarts from the last matched
2130 * location until nothing matches anymore. First arg is the regex to apply to
2131 * the input string, second arg is the replacement expression.
2132 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002133static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002134{
2135 char *start, *end;
2136 struct my_regex *reg = arg_p[0].data.reg;
2137 regmatch_t pmatch[MAX_MATCH];
2138 struct chunk *trash = get_trash_chunk();
2139 int flag, max;
2140 int found;
2141
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002142 start = smp->data.u.str.str;
2143 end = start + smp->data.u.str.len;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002144
2145 flag = 0;
2146 while (1) {
2147 /* check for last round which is used to copy remaining parts
2148 * when not running in global replacement mode.
2149 */
2150 found = 0;
2151 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2152 /* Note: we can have start == end on empty strings or at the end */
2153 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2154 }
2155
2156 if (!found)
2157 pmatch[0].rm_so = end - start;
2158
2159 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
2160 max = trash->size - trash->len;
2161 if (max && pmatch[0].rm_so > 0) {
2162 if (max > pmatch[0].rm_so)
2163 max = pmatch[0].rm_so;
2164 memcpy(trash->str + trash->len, start, max);
2165 trash->len += max;
2166 }
2167
2168 if (!found)
2169 break;
2170
2171 /* replace the matching part */
2172 max = trash->size - trash->len;
2173 if (max) {
2174 if (max > arg_p[1].data.str.len)
2175 max = arg_p[1].data.str.len;
2176 memcpy(trash->str + trash->len, arg_p[1].data.str.str, max);
2177 trash->len += max;
2178 }
2179
2180 /* stop here if we're done with this string */
2181 if (start >= end)
2182 break;
2183
2184 /* We have a special case for matches of length 0 (eg: "x*y*").
2185 * These ones are considered to match in front of a character,
2186 * so we have to copy that character and skip to the next one.
2187 */
2188 if (!pmatch[0].rm_eo) {
2189 if (trash->len < trash->size)
2190 trash->str[trash->len++] = start[pmatch[0].rm_eo];
2191 pmatch[0].rm_eo++;
2192 }
2193
2194 start += pmatch[0].rm_eo;
2195 flag |= REG_NOTBOL;
2196 }
2197
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002198 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002199 return 1;
2200}
2201
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002202/* This function check an operator entry. It expects a string.
2203 * The string can be an integer or a variable name.
2204 */
2205static int check_operator(struct arg *args, struct sample_conv *conv,
2206 const char *file, int line, char **err)
2207{
2208 const char *str;
2209 const char *end;
2210
2211 /* Try to decode a variable. */
2212 if (vars_check_arg(&args[0], NULL))
2213 return 1;
2214
2215 /* Try to convert an integer */
2216 str = args[0].data.str.str;
2217 end = str + strlen(str);
2218 args[0].data.sint = read_int64(&str, end);
2219 if (*str != '\0') {
2220 memprintf(err, "expects an integer or a variable name");
2221 return 0;
2222 }
2223 args[0].type = ARGT_SINT;
2224 return 1;
2225}
2226
Willy Tarreau6204cd92016-03-10 16:33:04 +01002227/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002228 * If the arg contain an integer, the integer is returned in the
2229 * sample. If the arg contains a variable descriptor, it returns the
2230 * variable value.
2231 *
2232 * This function returns 0 if an error occurs, otherwise it returns 1.
2233 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002234static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002235{
2236 switch (arg->type) {
2237 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002238 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002239 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002240 return 1;
2241 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002242 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002243 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002244 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002245 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002246 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002247 return 0;
2248 return 1;
2249 default:
2250 return 0;
2251 }
2252}
2253
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002254/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002255 * result.
2256 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002257static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002258{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002259 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002260 return 1;
2261}
2262
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002263/* Takes a SINT on input, applies a binary "and" with the SINT directly in
2264 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002265 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002266static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002267{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002268 struct sample tmp;
2269
Willy Tarreau7560dd42016-03-10 16:28:58 +01002270 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002271 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002272 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002273 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002274 return 1;
2275}
2276
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002277/* Takes a SINT on input, applies a binary "or" with the SINT directly in
2278 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002279 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002280static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002281{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002282 struct sample tmp;
2283
Willy Tarreau7560dd42016-03-10 16:28:58 +01002284 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002285 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002286 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002287 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002288 return 1;
2289}
2290
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002291/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
2292 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002293 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002294static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002295{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002296 struct sample tmp;
2297
Willy Tarreau7560dd42016-03-10 16:28:58 +01002298 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002299 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002300 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002301 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002302 return 1;
2303}
2304
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002305static inline long long int arith_add(long long int a, long long int b)
2306{
2307 /* Prevent overflow and makes capped calculus.
2308 * We must ensure that the check calculus doesn't
2309 * exceed the signed 64 bits limits.
2310 *
2311 * +----------+----------+
2312 * | a<0 | a>=0 |
2313 * +------+----------+----------+
2314 * | b<0 | MIN-a>b | no check |
2315 * +------+----------+----------+
2316 * | b>=0 | no check | MAX-a<b |
2317 * +------+----------+----------+
2318 */
2319 if ((a ^ b) >= 0) {
2320 /* signs are differents. */
2321 if (a < 0) {
2322 if (LLONG_MIN - a > b)
2323 return LLONG_MIN;
2324 }
2325 if (LLONG_MAX - a < b)
2326 return LLONG_MAX;
2327 }
2328 return a + b;
2329}
2330
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002331/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
2332 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002333 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002334static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002335{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002336 struct sample tmp;
2337
Willy Tarreau7560dd42016-03-10 16:28:58 +01002338 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002339 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002340 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002341 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002342 return 1;
2343}
2344
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002345/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
2346 * arg_p or in the varaible described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002347 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002348static int sample_conv_arith_sub(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 FOURNIER5d86fae2015-07-07 21:10:16 +02002351 struct sample tmp;
2352
Willy Tarreau7560dd42016-03-10 16:28:58 +01002353 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002354 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002355 return 0;
2356
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002357 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2358 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2359 * of -LLONG_MIN and correct the result.
2360 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002361 if (tmp.data.u.sint == LLONG_MIN) {
2362 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2363 if (smp->data.u.sint < LLONG_MAX)
2364 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002365 return 1;
2366 }
2367
2368 /* standard substraction: we use the "add" function and negate
2369 * the second operand.
2370 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002371 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002372 return 1;
2373}
2374
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002375/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
2376 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2377 * If the result makes an overflow, then the largest possible quantity is
2378 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002379 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002380static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002381 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002382{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002383 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002384 long long int c;
2385
Willy Tarreau7560dd42016-03-10 16:28:58 +01002386 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002387 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002388 return 0;
2389
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002390 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002391 if (!smp->data.u.sint || !tmp.data.u.sint) {
2392 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002393 return 1;
2394 }
2395
2396 /* The multiply between LLONG_MIN and -1 returns a
2397 * "floting point exception".
2398 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002399 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2400 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002401 return 1;
2402 }
2403
2404 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002405 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002406
2407 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002408 if (smp->data.u.sint != c / tmp.data.u.sint) {
2409 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2410 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002411 return 1;
2412 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002413 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002414 return 1;
2415 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002416 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002417 return 1;
2418}
2419
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002420/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
2421 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2422 * If arg_p makes the result overflow, then the largest possible quantity is
2423 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002424 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002425static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002426 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002427{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002428 struct sample tmp;
2429
Willy Tarreau7560dd42016-03-10 16:28:58 +01002430 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002431 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002432 return 0;
2433
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002434 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002435 /* The divide between LLONG_MIN and -1 returns a
2436 * "floting point exception".
2437 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002438 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2439 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002440 return 1;
2441 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002442 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002443 return 1;
2444 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002445 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002446 return 1;
2447}
2448
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002449/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
2450 * arg_p or in the varaible described in arg_p, and returns the SINT result.
2451 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002452 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002453static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002454 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002455{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002456 struct sample tmp;
2457
Willy Tarreau7560dd42016-03-10 16:28:58 +01002458 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002459 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002460 return 0;
2461
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002462 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002463 /* The divide between LLONG_MIN and -1 returns a
2464 * "floting point exception".
2465 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002466 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2467 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002468 return 1;
2469 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002470 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002471 return 1;
2472 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002473 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002474 return 1;
2475}
2476
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002477/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002478 * result.
2479 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002480static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002481 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002482{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002483 if (smp->data.u.sint == LLONG_MIN)
2484 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002485 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002486 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002487 return 1;
2488}
2489
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002490/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002491 * false. The output is a BOOL.
2492 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002493static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002494 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002495{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002496 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002497 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002498 return 1;
2499}
2500
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002501/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002502 * truee. The output is a BOOL.
2503 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002504static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002505 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002506{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002507 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002508 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002509 return 1;
2510}
2511
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002512/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002513 * The output is a BOOL.
2514 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002515static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002516 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002517{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002518 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002519 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002520 return 1;
2521}
2522
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002523/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002524 * The output is a BOOL.
2525 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002526static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002527 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002528{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002529 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002530 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002531 return 1;
2532}
2533
Willy Tarreau280f42b2018-02-19 15:34:12 +01002534/* appends an optional const string, an optional variable contents and another
2535 * optional const string to an existing string.
2536 */
2537static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
2538{
2539 struct chunk *trash;
2540 struct sample tmp;
2541 int max;
2542
2543 trash = get_trash_chunk();
2544 trash->len = smp->data.u.str.len;
2545 if (trash->len > trash->size - 1)
2546 trash->len = trash->size - 1;
2547
2548 memcpy(trash->str, smp->data.u.str.str, trash->len);
2549 trash->str[trash->len] = 0;
2550
2551 /* append first string */
2552 max = arg_p[0].data.str.len;
2553 if (max > trash->size - 1 - trash->len)
2554 max = trash->size - 1 - trash->len;
2555
2556 if (max) {
2557 memcpy(trash->str + trash->len, arg_p[0].data.str.str, max);
2558 trash->len += max;
2559 trash->str[trash->len] = 0;
2560 }
2561
2562 /* append second string (variable) if it's found and we can turn it
2563 * into a string.
2564 */
2565 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
2566 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
2567 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
2568 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
2569
2570 max = tmp.data.u.str.len;
2571 if (max > trash->size - 1 - trash->len)
2572 max = trash->size - 1 - trash->len;
2573
2574 if (max) {
2575 memcpy(trash->str + trash->len, tmp.data.u.str.str, max);
2576 trash->len += max;
2577 trash->str[trash->len] = 0;
2578 }
2579 }
2580
2581 /* append third string */
2582 max = arg_p[2].data.str.len;
2583 if (max > trash->size - 1 - trash->len)
2584 max = trash->size - 1 - trash->len;
2585
2586 if (max) {
2587 memcpy(trash->str + trash->len, arg_p[2].data.str.str, max);
2588 trash->len += max;
2589 trash->str[trash->len] = 0;
2590 }
2591
2592 smp->data.u.str = *trash;
2593 smp->data.type = SMP_T_STR;
2594 return 1;
2595}
2596
2597/* This function checks the "concat" converter's arguments and extracts the
2598 * variable name and its scope.
2599 */
2600static int smp_check_concat(struct arg *args, struct sample_conv *conv,
2601 const char *file, int line, char **err)
2602{
2603 /* Try to decode a variable. */
2604 if (args[1].data.str.len > 0 && !vars_check_arg(&args[1], NULL)) {
2605 memprintf(err, "failed to register variable name '%s'", args[1].data.str.str);
2606 return 0;
2607 }
2608 return 1;
2609}
2610
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002611/************************************************************************/
2612/* All supported sample fetch functions must be declared here */
2613/************************************************************************/
2614
2615/* force TRUE to be returned at the fetch level */
2616static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002617smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002618{
Willy Tarreau280f42b2018-02-19 15:34:12 +01002619 if (!smp_make_rw(smp))
2620 return 0;
2621
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002622 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002623 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002624 return 1;
2625}
2626
2627/* force FALSE to be returned at the fetch level */
2628static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002629smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002630{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002631 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002632 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002633 return 1;
2634}
2635
2636/* retrieve environment variable $1 as a string */
2637static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002638smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002639{
2640 char *env;
2641
2642 if (!args || args[0].type != ARGT_STR)
2643 return 0;
2644
2645 env = getenv(args[0].data.str.str);
2646 if (!env)
2647 return 0;
2648
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002649 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002650 smp->flags = SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002651 smp->data.u.str.str = env;
2652 smp->data.u.str.len = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002653 return 1;
2654}
2655
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002656/* retrieve the current local date in epoch time, and applies an optional offset
2657 * of args[0] seconds.
2658 */
2659static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002660smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002661{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002662 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002663
2664 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002665 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002666 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002667
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002668 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002669 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2670 return 1;
2671}
2672
Etienne Carrierea792a0a2018-01-17 13:43:24 +01002673/* retrieve the current microsecond part of the date */
2674static int
2675smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
2676{
2677 smp->data.u.sint = date.tv_usec;
2678 smp->data.type = SMP_T_SINT;
2679 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2680 return 1;
2681}
2682
2683
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01002684/* returns the hostname */
2685static int
2686smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
2687{
2688 smp->data.type = SMP_T_STR;
2689 smp->flags = SMP_F_CONST;
2690 smp->data.u.str.str = hostname;
2691 smp->data.u.str.len = strlen(hostname);
2692 return 1;
2693}
2694
Willy Tarreau0f30d262014-11-24 16:02:05 +01002695/* returns the number of processes */
2696static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002697smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002698{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002699 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002700 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002701 return 1;
2702}
2703
2704/* returns the number of the current process (between 1 and nbproc */
2705static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002706smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002707{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002708 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002709 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002710 return 1;
2711}
2712
Christopher Faulet34adb2a2017-11-21 21:45:38 +01002713/* returns the number of the current thread (between 1 and nbthread */
2714static int
2715smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
2716{
2717 smp->data.type = SMP_T_SINT;
2718 smp->data.u.sint = tid;
2719 return 1;
2720}
2721
Willy Tarreau84310e22014-02-14 11:59:04 +01002722/* generate a random 32-bit integer for whatever purpose, with an optional
2723 * range specified in argument.
2724 */
2725static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002726smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01002727{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002728 smp->data.u.sint = random();
Willy Tarreau84310e22014-02-14 11:59:04 +01002729
2730 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002731 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002732 smp->data.u.sint = (smp->data.u.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
Willy Tarreau84310e22014-02-14 11:59:04 +01002733
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002734 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01002735 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2736 return 1;
2737}
2738
Willy Tarreau0f30d262014-11-24 16:02:05 +01002739/* returns true if the current process is stopping */
2740static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002741smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002742{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002743 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002744 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01002745 return 1;
2746}
2747
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002748static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
2749{
2750 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002751 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002752 smp->data.u.str.str = args[0].data.str.str;
2753 smp->data.u.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002754 return 1;
2755}
2756
2757static int smp_check_const_bool(struct arg *args, char **err)
2758{
2759 if (strcasecmp(args[0].data.str.str, "true") == 0 ||
2760 strcasecmp(args[0].data.str.str, "1") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002761 args[0].type = ARGT_SINT;
2762 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002763 return 1;
2764 }
2765 if (strcasecmp(args[0].data.str.str, "false") == 0 ||
2766 strcasecmp(args[0].data.str.str, "0") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002767 args[0].type = ARGT_SINT;
2768 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002769 return 1;
2770 }
2771 memprintf(err, "Expects 'true', 'false', '0' or '1'");
2772 return 0;
2773}
2774
2775static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
2776{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002777 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002778 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002779 return 1;
2780}
2781
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002782static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002783{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002784 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002785 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002786 return 1;
2787}
2788
2789static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
2790{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002791 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002792 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002793 return 1;
2794}
2795
2796static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
2797{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002798 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002799 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002800 return 1;
2801}
2802
2803static int smp_check_const_bin(struct arg *args, char **err)
2804{
David Carlier64a16ab2016-04-08 10:37:02 +01002805 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002806 int binstrlen;
2807
2808 if (!parse_binary(args[0].data.str.str, &binstr, &binstrlen, err))
2809 return 0;
2810 args[0].type = ARGT_STR;
2811 args[0].data.str.str = binstr;
2812 args[0].data.str.len = binstrlen;
2813 return 1;
2814}
2815
2816static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
2817{
2818 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002819 smp->data.type = SMP_T_BIN;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002820 smp->data.u.str.str = args[0].data.str.str;
2821 smp->data.u.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002822 return 1;
2823}
2824
2825static int smp_check_const_meth(struct arg *args, char **err)
2826{
2827 enum http_meth_t meth;
2828 int i;
2829
2830 meth = find_http_meth(args[0].data.str.str, args[0].data.str.len);
2831 if (meth != HTTP_METH_OTHER) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002832 args[0].type = ARGT_SINT;
2833 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002834 } else {
2835 /* Check method avalaibility. A methos is a token defined as :
2836 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
2837 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
2838 * token = 1*tchar
2839 */
2840 for (i = 0; i < args[0].data.str.len; i++) {
Willy Tarreau2235b262016-11-05 15:50:20 +01002841 if (!HTTP_IS_TOKEN(args[0].data.str.str[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002842 memprintf(err, "expects valid method.");
2843 return 0;
2844 }
2845 }
2846 }
2847 return 1;
2848}
2849
2850static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
2851{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002852 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002853 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002854 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002855 smp->data.u.meth.meth = args[0].data.sint;
2856 smp->data.u.meth.str.str = "";
2857 smp->data.u.meth.str.len = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002858 } else {
2859 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002860 smp->data.u.meth.meth = HTTP_METH_OTHER;
2861 smp->data.u.meth.str.str = args[0].data.str.str;
2862 smp->data.u.meth.str.len = args[0].data.str.len;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002863 }
2864 return 1;
2865}
2866
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002867/* Note: must not be declared <const> as its list will be overwritten.
2868 * Note: fetches that may return multiple types must be declared as the lowest
2869 * common denominator, the type that can be casted into all other ones. For
2870 * instance IPv4/IPv6 must be declared IPv4.
2871 */
2872static struct sample_fetch_kw_list smp_kws = {ILH, {
2873 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
2874 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002875 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002876 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Etienne Carrierea792a0a2018-01-17 13:43:24 +01002877 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01002878 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002879 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
2880 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01002881 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002882 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01002883 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002884
2885 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
2886 { "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 +02002887 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02002888 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
2889 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
2890 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
2891 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
2892
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002893 { /* END */ },
2894}};
2895
Emeric Brun107ca302010-01-04 16:16:05 +01002896/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02002897static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER9687c772015-05-07 15:46:29 +02002898#ifdef DEBUG_EXPR
2899 { "debug", sample_conv_debug, 0, NULL, SMP_T_ANY, SMP_T_ANY },
2900#endif
2901
Holger Just1bfc24b2017-05-06 00:56:53 +02002902 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02002903 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002904 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
2905 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01002906 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002907 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02002908 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002909 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002910 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
2911 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002912 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2913 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2914 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2915 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002916 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
2917 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002918 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002919 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
2920 { "field", sample_conv_field, ARG2(2,SINT,STR), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
2921 { "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 +01002922 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02002923 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Willy Tarreau280f42b2018-02-19 15:34:12 +01002924 { "concat", sample_conv_concat, ARG3(1,STR,STR,STR), smp_check_concat, SMP_T_STR, SMP_T_STR },
Willy Tarreau97707872015-01-27 15:12:13 +01002925
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002926 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2927 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2928 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2929 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
2930 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2931 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2932 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2933 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
2934 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2935 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2936 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2937 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2938 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
2939 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01002940
Willy Tarreau9fcb9842012-04-20 14:45:49 +02002941 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01002942}};
2943
2944__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02002945static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01002946{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002947 /* register sample fetch and format conversion keywords */
2948 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02002949 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01002950}