blob: 3ad2d208103cbb5cd053a7fc7ae331e74377c597 [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>
Emeric Brun107ca302010-01-04 16:16:05 +010034
Willy Tarreau1cf8f082014-02-07 12:14:54 +010035/* sample type names */
36const char *smp_to_type[SMP_TYPES] = {
37 [SMP_T_BOOL] = "bool",
38 [SMP_T_UINT] = "uint",
39 [SMP_T_SINT] = "sint",
40 [SMP_T_ADDR] = "addr",
41 [SMP_T_IPV4] = "ipv4",
42 [SMP_T_IPV6] = "ipv6",
43 [SMP_T_STR] = "str",
44 [SMP_T_BIN] = "bin",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010045};
46
Willy Tarreau12785782012-04-27 21:37:17 +020047/* static sample used in sample_process() when <p> is NULL */
Willy Tarreaub4a88f02012-04-23 21:35:11 +020048static struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010049
Willy Tarreau12785782012-04-27 21:37:17 +020050/* list head of all known sample fetch keywords */
51static struct sample_fetch_kw_list sample_fetches = {
52 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010053};
54
Willy Tarreau12785782012-04-27 21:37:17 +020055/* list head of all known sample format conversion keywords */
56static struct sample_conv_kw_list sample_convs = {
57 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010058};
59
Willy Tarreau80aca902013-01-07 15:42:20 +010060const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
61 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
62 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
63 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
64 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
65 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
66 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
67 SMP_VAL_FE_LOG_END),
68
69 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
70 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
71 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
72 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
73 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
74 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
75 SMP_VAL_FE_LOG_END),
76
77 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
78 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
79 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
80 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
81 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
82 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
83 SMP_VAL_FE_LOG_END),
84
85 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
86 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
87 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
88 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
89 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
90 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
91 SMP_VAL_FE_LOG_END),
92
93 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
94 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
95 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
96 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
97 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
98 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
99 SMP_VAL_FE_LOG_END),
100
101 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
102 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
103 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
104 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
105 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
106 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
107 SMP_VAL_FE_LOG_END),
108
109 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
110 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
111 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
112 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
113 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
114 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
115 SMP_VAL___________),
116
117 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
118 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
119 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
120 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
121 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
122 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
123 SMP_VAL___________),
124
125 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
126 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
127 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
128 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
129 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
130 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
131 SMP_VAL_FE_LOG_END),
132
133 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
134 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
135 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
136 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
137 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
138 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
139 SMP_VAL___________),
140
141 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
142 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
143 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
144 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
145 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
146 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
147 SMP_VAL_FE_LOG_END),
148
149 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
150 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
151 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
152 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
153 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
154 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
155 SMP_VAL_FE_LOG_END),
156
157 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
158 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
159 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
160 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
161 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
162 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
163 SMP_VAL_FE_LOG_END),
164
165 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
166 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
167 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
168 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
169 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
170 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
171 SMP_VAL_FE_LOG_END),
172
173 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
174 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
175 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
176 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
177 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
178 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
179 SMP_VAL___________),
180
181 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
182 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
183 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
184 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
185 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
186 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
187 SMP_VAL___________),
188
189 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
190 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
191 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
192 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
193 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
194 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
195 SMP_VAL_FE_LOG_END),
196
197 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
198 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
199 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
200 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
201 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
202 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
203 SMP_VAL___________),
204
205 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
206 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
207 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
208 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
209 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
210 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
211 SMP_VAL_FE_LOG_END),
212
213 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
214 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
215 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
216 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
217 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
218 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL_FE_LOG_END),
220
221 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
222 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
223 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
224 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
225 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
226 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
227 SMP_VAL_FE_LOG_END),
228
229 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
230 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
231 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
232 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
233 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
234 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
235 SMP_VAL_FE_LOG_END),
236};
237
238static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
239 [SMP_SRC_INTRN] = "internal state",
240 [SMP_SRC_LISTN] = "listener",
241 [SMP_SRC_FTEND] = "frontend",
242 [SMP_SRC_L4CLI] = "client address",
243 [SMP_SRC_L5CLI] = "client-side connection",
244 [SMP_SRC_TRACK] = "track counters",
245 [SMP_SRC_L6REQ] = "request buffer",
246 [SMP_SRC_HRQHV] = "HTTP request headers",
247 [SMP_SRC_HRQHP] = "HTTP request",
248 [SMP_SRC_HRQBO] = "HTTP request body",
249 [SMP_SRC_BKEND] = "backend",
250 [SMP_SRC_SERVR] = "server",
251 [SMP_SRC_L4SRV] = "server address",
252 [SMP_SRC_L5SRV] = "server-side connection",
253 [SMP_SRC_L6RES] = "response buffer",
254 [SMP_SRC_HRSHV] = "HTTP response headers",
255 [SMP_SRC_HRSHP] = "HTTP response",
256 [SMP_SRC_HRSBO] = "HTTP response body",
257 [SMP_SRC_RQFIN] = "request buffer statistics",
258 [SMP_SRC_RSFIN] = "response buffer statistics",
259 [SMP_SRC_TXFIN] = "transaction statistics",
260 [SMP_SRC_SSFIN] = "session statistics",
261};
262
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100263static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
264 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
265 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
266 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
267 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
268 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
269 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
270 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
271 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
272 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
273 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
274 [SMP_CKP_BE_SRV_CON] = "server source selection",
275 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
276 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
277 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
278 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
279 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
280 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
281 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
282 [SMP_CKP_FE_LOG_END] = "logs",
283};
284
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100285/* This function returns the type of the data returned by the sample_expr.
286 * It assumes that the <expr> and all of its converters are properly
287 * initialized.
288 */
289inline
290int smp_expr_output_type(struct sample_expr *expr)
291{
292 struct sample_conv_expr *smp_expr;
293
294 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
295 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
296 return smp_expr->conv->out_type;
297 }
298 return expr->fetch->out_type;
299}
300
301
Willy Tarreau80aca902013-01-07 15:42:20 +0100302/* fill the trash with a comma-delimited list of source names for the <use> bit
303 * field which must be composed of a non-null set of SMP_USE_* flags. The return
304 * value is the pointer to the string in the trash buffer.
305 */
306const char *sample_src_names(unsigned int use)
307{
308 int bit;
309
310 trash.len = 0;
311 trash.str[0] = '\0';
312 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
313 if (!(use & ~((1 << bit) - 1)))
314 break; /* no more bits */
315
316 if (!(use & (1 << bit)))
317 continue; /* bit not set */
318
319 trash.len += snprintf(trash.str + trash.len, trash.size - trash.len, "%s%s",
320 (use & ((1 << bit) - 1)) ? "," : "",
321 fetch_src_names[bit]);
322 }
323 return trash.str;
324}
325
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100326/* return a pointer to the correct sample checkpoint name, or "unknown" when
327 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
328 * if set.
329 */
330const char *sample_ckp_names(unsigned int use)
331{
332 int bit;
333
334 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
335 if (use & (1 << bit))
336 return fetch_ckp_names[bit];
337 return "unknown sample check place, please report this bug";
338}
339
Emeric Brun107ca302010-01-04 16:16:05 +0100340/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100341 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
342 * for next parsing sessions. The fetch keywords capabilities are also computed
343 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100344 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100345void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100346{
Willy Tarreau80aca902013-01-07 15:42:20 +0100347 struct sample_fetch *sf;
348 int bit;
349
350 for (sf = kwl->kw; sf->kw != NULL; sf++) {
351 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
352 if (sf->use & (1 << bit))
353 sf->val |= fetch_cap[bit];
354 }
355 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100356}
357
358/*
Willy Tarreau12785782012-04-27 21:37:17 +0200359 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100360 * parsing sessions.
361 */
Willy Tarreau12785782012-04-27 21:37:17 +0200362void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100363{
Willy Tarreau12785782012-04-27 21:37:17 +0200364 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100365}
366
367/*
Willy Tarreau12785782012-04-27 21:37:17 +0200368 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100369 * string of <len> in buffer <kw>.
370 *
371 */
Willy Tarreau12785782012-04-27 21:37:17 +0200372struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100373{
374 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200375 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100376
Willy Tarreau12785782012-04-27 21:37:17 +0200377 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100378 for (index = 0; kwl->kw[index].kw != NULL; index++) {
379 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
380 kwl->kw[index].kw[len] == '\0')
381 return &kwl->kw[index];
382 }
383 }
384 return NULL;
385}
386
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100387/* This fucntion browse the list of available saple fetch. <current> is
388 * the last used sample fetch. If it is the first call, it must set to NULL.
389 * <idx> is the index of the next sampleèfetch entry. It is used as private
390 * value. It is useles to initiate it.
391 *
392 * It returns always the newt fetch_sample entry, and NULL when the end of
393 * the list is reached.
394 */
395struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
396{
397 struct sample_fetch_kw_list *kwl;
398 struct sample_fetch *base;
399
400 if (!current) {
401 /* Get first kwl entry. */
402 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
403 (*idx) = 0;
404 } else {
405 /* Get kwl corresponding to the curret entry. */
406 base = current + 1 - (*idx);
407 kwl = container_of(base, struct sample_fetch_kw_list, kw);
408 }
409
410 while (1) {
411
412 /* Check if kwl is the last entry. */
413 if (&kwl->list == &sample_fetches.list)
414 return NULL;
415
416 /* idx contain the next keyword. If it is available, return it. */
417 if (kwl->kw[*idx].kw) {
418 (*idx)++;
419 return &kwl->kw[(*idx)-1];
420 }
421
422 /* get next entry in the main list, and return NULL if the end is reached. */
423 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
424
425 /* Set index to 0, ans do one other loop. */
426 (*idx) = 0;
427 }
428}
429
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100430/* This function browses the list of available converters. <current> is
431 * the last used converter. If it is the first call, it must set to NULL.
432 * <idx> is the index of the next converter entry. It is used as private
433 * value. It is useless to initiate it.
434 *
435 * It returns always the next sample_conv entry, and NULL when the end of
436 * the list is reached.
437 */
438struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
439{
440 struct sample_conv_kw_list *kwl;
441 struct sample_conv *base;
442
443 if (!current) {
444 /* Get first kwl entry. */
445 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
446 (*idx) = 0;
447 } else {
448 /* Get kwl corresponding to the curret entry. */
449 base = current + 1 - (*idx);
450 kwl = container_of(base, struct sample_conv_kw_list, kw);
451 }
452
453 while (1) {
454 /* Check if kwl is the last entry. */
455 if (&kwl->list == &sample_convs.list)
456 return NULL;
457
458 /* idx contain the next keyword. If it is available, return it. */
459 if (kwl->kw[*idx].kw) {
460 (*idx)++;
461 return &kwl->kw[(*idx)-1];
462 }
463
464 /* get next entry in the main list, and return NULL if the end is reached. */
465 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
466
467 /* Set index to 0, ans do one other loop. */
468 (*idx) = 0;
469 }
470}
471
Emeric Brun107ca302010-01-04 16:16:05 +0100472/*
Willy Tarreau12785782012-04-27 21:37:17 +0200473 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100474 * string of <len> in buffer <kw>.
475 *
476 */
Willy Tarreau12785782012-04-27 21:37:17 +0200477struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100478{
479 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200480 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100481
Willy Tarreau12785782012-04-27 21:37:17 +0200482 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100483 for (index = 0; kwl->kw[index].kw != NULL; index++) {
484 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
485 kwl->kw[index].kw[len] == '\0')
486 return &kwl->kw[index];
487 }
488 }
489 return NULL;
490}
491
Emeric Brun107ca302010-01-04 16:16:05 +0100492/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200493/* Sample casts functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +0200494/* Note: these functions do *NOT* set the output type on the */
495/* sample, the caller is responsible for doing this on return. */
Emeric Brun107ca302010-01-04 16:16:05 +0100496/******************************************************************/
497
Willy Tarreau342acb42012-04-23 22:03:39 +0200498static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100499{
Willy Tarreau342acb42012-04-23 22:03:39 +0200500 smp->data.uint = ntohl(smp->data.ipv4.s_addr);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100501 smp->type = SMP_T_UINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100502 return 1;
503}
504
Willy Tarreau342acb42012-04-23 22:03:39 +0200505static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100506{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100507 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100508
Willy Tarreau342acb42012-04-23 22:03:39 +0200509 if (!inet_ntop(AF_INET, (void *)&smp->data.ipv4, trash->str, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100510 return 0;
511
512 trash->len = strlen(trash->str);
Willy Tarreau342acb42012-04-23 22:03:39 +0200513 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100514 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100515 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100516
517 return 1;
518}
519
Willy Tarreau342acb42012-04-23 22:03:39 +0200520static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100521{
Willy Tarreau342acb42012-04-23 22:03:39 +0200522 v4tov6(&smp->data.ipv6, &smp->data.ipv4);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100523 smp->type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100524 return 1;
525}
526
Willy Tarreau342acb42012-04-23 22:03:39 +0200527static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100528{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100529 struct chunk *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100530
Willy Tarreau342acb42012-04-23 22:03:39 +0200531 if (!inet_ntop(AF_INET6, (void *)&smp->data.ipv6, trash->str, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100532 return 0;
533
534 trash->len = strlen(trash->str);
Willy Tarreau342acb42012-04-23 22:03:39 +0200535 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100536 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100537 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100538 return 1;
539}
540
541/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200542static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100543{
Willy Tarreau342acb42012-04-23 22:03:39 +0200544 return v6tov4(&smp->data.ipv4, &smp->data.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100545}
546*/
547
Willy Tarreau342acb42012-04-23 22:03:39 +0200548static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100549{
Willy Tarreau342acb42012-04-23 22:03:39 +0200550 smp->data.ipv4.s_addr = htonl(smp->data.uint);
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100551 smp->type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100552 return 1;
553}
554
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100555static int c_str2addr(struct sample *smp)
556{
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100557 if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) {
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100558 if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6))
559 return 0;
560 smp->type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100561 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100562 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100563 }
564 smp->type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100565 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100566 return 1;
567}
568
Willy Tarreau342acb42012-04-23 22:03:39 +0200569static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100570{
Willy Tarreau342acb42012-04-23 22:03:39 +0200571 if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100572 return 0;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100573 smp->type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100574 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100575 return 1;
576}
577
Willy Tarreau342acb42012-04-23 22:03:39 +0200578static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100579{
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100580 if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6))
581 return 0;
582 smp->type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100583 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100584 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100585}
586
Emeric Brun4b9e8022014-11-03 18:17:10 +0100587/*
588 * The NULL char always enforces the end of string if it is met.
589 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100590 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200591static int c_bin2str(struct sample *smp)
592{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100593 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200594
Emeric Brun4b9e8022014-11-03 18:17:10 +0100595 for (i = 0; i < smp->data.str.len; i++) {
596 if (!smp->data.str.str[i]) {
597 smp->data.str.len = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100598 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100599 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200600 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200601 return 1;
602}
603
Willy Tarreau342acb42012-04-23 22:03:39 +0200604static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100605{
Willy Tarreau47ca5452012-12-23 20:22:19 +0100606 struct chunk *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100607 char *pos;
608
Willy Tarreau342acb42012-04-23 22:03:39 +0200609 pos = ultoa_r(smp->data.uint, trash->str, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100610
611 if (!pos)
612 return 0;
613
Emeric Brun485479d2010-09-23 18:02:19 +0200614 trash->size = trash->size - (pos - trash->str);
Emeric Brun107ca302010-01-04 16:16:05 +0100615 trash->str = pos;
616 trash->len = strlen(pos);
Willy Tarreau342acb42012-04-23 22:03:39 +0200617 smp->data.str = *trash;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100618 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100619 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100620 return 1;
621}
622
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100623/* This function duplicates data and removes the flag "const". */
624int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200625{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100626 struct chunk *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200627
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100628 /* If the const flag is not set, we don't need to duplicate the
629 * pattern as it can be modified in place.
630 */
631 if (!(smp->flags & SMP_F_CONST))
632 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100633
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100634 switch (smp->type) {
635 case SMP_T_BOOL:
636 case SMP_T_UINT:
637 case SMP_T_SINT:
638 case SMP_T_ADDR:
639 case SMP_T_IPV4:
640 case SMP_T_IPV6:
641 /* These type are not const. */
642 break;
643 case SMP_T_STR:
644 case SMP_T_BIN:
645 /* Duplicate data. */
646 trash = get_trash_chunk();
647 trash->len = smp->data.str.len < trash->size ? smp->data.str.len : trash->size;
648 memcpy(trash->str, smp->data.str.str, trash->len);
649 smp->data.str = *trash;
650 break;
651 default:
652 /* Other cases are unexpected. */
653 return 0;
654 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100655
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100656 /* remove const flag */
657 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200658 return 1;
659}
660
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100661int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100662{
663 return 1;
664}
665
Willy Tarreau342acb42012-04-23 22:03:39 +0200666static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100667{
668 int i;
669 uint32_t ret = 0;
670
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100671 if (smp->data.str.len == 0)
672 return 0;
673
Willy Tarreau342acb42012-04-23 22:03:39 +0200674 for (i = 0; i < smp->data.str.len; i++) {
675 uint32_t val = smp->data.str.str[i] - '0';
Emeric Brun107ca302010-01-04 16:16:05 +0100676
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100677 if (val > 9) {
678 if (i == 0)
679 return 0;
Emeric Brun107ca302010-01-04 16:16:05 +0100680 break;
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100681 }
Emeric Brun107ca302010-01-04 16:16:05 +0100682
683 ret = ret * 10 + val;
684 }
685
Willy Tarreau342acb42012-04-23 22:03:39 +0200686 smp->data.uint = ret;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100687 smp->type = SMP_T_UINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100688 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100689 return 1;
690}
691
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100692static int c_str2meth(struct sample *smp)
693{
694 enum http_meth_t meth;
695 int len;
696
697 meth = find_http_meth(smp->data.str.str, smp->data.str.len);
698 if (meth == HTTP_METH_OTHER) {
699 len = smp->data.str.len;
700 smp->data.meth.str.str = smp->data.str.str;
701 smp->data.meth.str.len = len;
702 }
703 else
704 smp->flags &= ~SMP_F_CONST;
705 smp->data.meth.meth = meth;
706 smp->type = SMP_T_METH;
707 return 1;
708}
709
710static int c_meth2str(struct sample *smp)
711{
712 int len;
713 enum http_meth_t meth;
714
715 if (smp->data.meth.meth == HTTP_METH_OTHER) {
716 /* The method is unknown. Copy the original pointer. */
717 len = smp->data.meth.str.len;
718 smp->data.str.str = smp->data.meth.str.str;
719 smp->data.str.len = len;
720 smp->type = SMP_T_STR;
721 }
722 else if (smp->data.meth.meth < HTTP_METH_OTHER) {
723 /* The method is known, copy the pointer containing the string. */
724 meth = smp->data.meth.meth;
725 smp->data.str.str = http_known_methods[meth].name;
726 smp->data.str.len = http_known_methods[meth].len;
727 smp->flags |= SMP_F_CONST;
728 smp->type = SMP_T_STR;
729 }
730 else {
731 /* Unknown method */
732 return 0;
733 }
734 return 1;
735}
736
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200737static int c_addr2bin(struct sample *smp)
738{
739 struct chunk *chk = get_trash_chunk();
740
741 if (smp->type == SMP_T_IPV4) {
742 chk->len = 4;
743 memcpy(chk->str, &smp->data.ipv4, chk->len);
744 }
745 else if (smp->type == SMP_T_IPV6) {
746 chk->len = 16;
747 memcpy(chk->str, &smp->data.ipv6, chk->len);
748 }
749 else
750 return 0;
751
752 smp->data.str = *chk;
753 smp->type = SMP_T_BIN;
754 return 1;
755}
756
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200757static int c_int2bin(struct sample *smp)
758{
759 struct chunk *chk = get_trash_chunk();
760
761 *(unsigned int *)chk->str = htonl(smp->data.uint);
762 chk->len = 4;
763
764 smp->data.str = *chk;
765 smp->type = SMP_T_BIN;
766 return 1;
767}
768
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200769
Emeric Brun107ca302010-01-04 16:16:05 +0100770/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200771/* Sample casts matrix: */
772/* sample_casts[from type][to type] */
773/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100774/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100775
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100776sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100777/* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN METH */
778/* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200779/* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, c_int2bin, NULL, },
780/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, c_int2bin, NULL, },
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100781/* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200782/* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
783/* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100784/* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
785/* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
786/* METH */ { NULL, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, },
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200787};
Emeric Brun107ca302010-01-04 16:16:05 +0100788
Emeric Brun107ca302010-01-04 16:16:05 +0100789/*
Willy Tarreau12785782012-04-27 21:37:17 +0200790 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100791 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200792 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200793 * The caller must have set al->ctx.
Emeric Brun107ca302010-01-04 16:16:05 +0100794 */
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100795struct 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 +0100796{
Willy Tarreau833cc792013-07-24 15:34:19 +0200797 const char *begw; /* beginning of word */
798 const char *endw; /* end of word */
799 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200800 struct sample_expr *expr;
801 struct sample_fetch *fetch;
802 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100803 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200804 char *fkw = NULL;
805 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100806 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100807
Willy Tarreau833cc792013-07-24 15:34:19 +0200808 begw = str[*idx];
809 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
810
811 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100812 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100813 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200814 }
Emeric Brun107ca302010-01-04 16:16:05 +0100815
Willy Tarreau833cc792013-07-24 15:34:19 +0200816 /* keep a copy of the current fetch keyword for error reporting */
817 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100818
Willy Tarreau833cc792013-07-24 15:34:19 +0200819 fetch = find_sample_fetch(begw, endw - begw);
820 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100821 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100822 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200823 }
Emeric Brun107ca302010-01-04 16:16:05 +0100824
Willy Tarreau833cc792013-07-24 15:34:19 +0200825 endt = endw;
826 if (*endt == '(') {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100827 /* look for the end of this term and skip the opening parenthesis */
828 endt = ++endw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200829 while (*endt && *endt != ')')
830 endt++;
831 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100832 memprintf(err_msg, "missing closing ')' after arguments to fetch keyword '%s'", fkw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200833 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200834 }
Emeric Brun485479d2010-09-23 18:02:19 +0200835 }
Emeric Brun107ca302010-01-04 16:16:05 +0100836
Willy Tarreau833cc792013-07-24 15:34:19 +0200837 /* At this point, we have :
838 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100839 * - endw : end of the keyword, first character not part of keyword
840 * nor the opening parenthesis (so first character of args
841 * if present).
Willy Tarreau833cc792013-07-24 15:34:19 +0200842 * - endt : end of the term (=endw or last parenthesis if args are present)
843 */
844
845 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100846 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100847 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200848 }
Emeric Brun107ca302010-01-04 16:16:05 +0100849 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200850
Willy Tarreau12785782012-04-27 21:37:17 +0200851 expr = calloc(1, sizeof(struct sample_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200852 if (!expr)
853 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100854
855 LIST_INIT(&(expr->conv_exprs));
856 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200857 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100858
Willy Tarreau689a1df2013-12-13 00:40:11 +0100859 /* Note that we call the argument parser even with an empty string,
860 * this allows it to automatically create entries for mandatory
861 * implicit arguments (eg: local proxy name).
862 */
863 al->kw = expr->fetch->kw;
864 al->conv = NULL;
865 if (make_arg_list(endw, endt - endw, fetch->arg_mask, &expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
866 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
867 goto out_error;
868 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200869
Willy Tarreau689a1df2013-12-13 00:40:11 +0100870 if (!expr->arg_p) {
871 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200872 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100873 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
874 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200875 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100876 }
877
Willy Tarreau833cc792013-07-24 15:34:19 +0200878 /* Now process the converters if any. We have two supported syntaxes
879 * for the converters, which can be combined :
880 * - comma-delimited list of converters just after the keyword and args ;
881 * - one converter per keyword
882 * The combination allows to have each keyword being a comma-delimited
883 * series of converters.
884 *
885 * We want to process the former first, then the latter. For this we start
886 * from the beginning of the supposed place in the exiting conv chain, which
887 * starts at the last comma (endt).
888 */
889
890 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200891 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +0100892
Willy Tarreau833cc792013-07-24 15:34:19 +0200893 if (*endt == ')') /* skip last closing parenthesis */
894 endt++;
Emeric Brun107ca302010-01-04 16:16:05 +0100895
Willy Tarreau833cc792013-07-24 15:34:19 +0200896 if (*endt && *endt != ',') {
897 if (ckw)
Willy Tarreau975c1782013-12-12 23:16:54 +0100898 memprintf(err_msg, "missing comma after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200899 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100900 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100901 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200902 }
Emeric Brun107ca302010-01-04 16:16:05 +0100903
Willy Tarreau833cc792013-07-24 15:34:19 +0200904 while (*endt == ',') /* then trailing commas */
905 endt++;
906
907 begw = endt; /* start of conv keyword */
908
909 if (!*begw) {
910 /* none ? skip to next string */
911 (*idx)++;
912 begw = str[*idx];
913 if (!begw || !*begw)
914 break;
915 }
916
917 for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++);
918
919 free(ckw);
920 ckw = my_strndup(begw, endw - begw);
921
922 conv = find_sample_conv(begw, endw - begw);
923 if (!conv) {
924 /* we found an isolated keyword that we don't know, it's not ours */
925 if (begw == str[*idx])
926 break;
Willy Tarreau975c1782013-12-12 23:16:54 +0100927 memprintf(err_msg, "unknown conv method '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200928 goto out_error;
929 }
Emeric Brun107ca302010-01-04 16:16:05 +0100930
Willy Tarreau833cc792013-07-24 15:34:19 +0200931 endt = endw;
932 if (*endt == '(') {
933 /* look for the end of this term */
934 while (*endt && *endt != ')')
935 endt++;
936 if (*endt != ')') {
Willy Tarreau975c1782013-12-12 23:16:54 +0100937 memprintf(err_msg, "syntax error: missing ')' after conv keyword '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200938 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200939 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200940 }
941
942 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100943 memprintf(err_msg, "returns type of conv method '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100944 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200945 }
Emeric Brun107ca302010-01-04 16:16:05 +0100946
947 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200948 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100949 memprintf(err_msg, "conv method '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100950 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200951 }
Emeric Brun107ca302010-01-04 16:16:05 +0100952
953 prev_type = conv->out_type;
Willy Tarreau12785782012-04-27 21:37:17 +0200954 conv_expr = calloc(1, sizeof(struct sample_conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200955 if (!conv_expr)
956 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100957
958 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
959 conv_expr->conv = conv;
960
Willy Tarreau833cc792013-07-24 15:34:19 +0200961 if (endt != endw) {
Willy Tarreaub27c0d32012-04-20 16:04:47 +0200962 int err_arg;
Willy Tarreau21d68a62012-04-20 15:52:36 +0200963
Willy Tarreau9fcb9842012-04-20 14:45:49 +0200964 if (!conv->arg_mask) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100965 memprintf(err_msg, "conv method '%s' does not support any args", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200966 goto out_error;
967 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100968
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200969 al->kw = expr->fetch->kw;
970 al->conv = conv_expr->conv->kw;
Willy Tarreau975c1782013-12-12 23:16:54 +0100971 if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, err_msg, NULL, &err_arg, al) < 0) {
972 memprintf(err_msg, "invalid arg %d in conv method '%s' : %s", err_arg+1, ckw, *err_msg);
Willy Tarreau21d68a62012-04-20 15:52:36 +0200973 goto out_error;
974 }
975
Willy Tarreau2e845be2012-10-19 19:49:09 +0200976 if (!conv_expr->arg_p)
977 conv_expr->arg_p = empty_arg_list;
978
Thierry FOURNIEReeaa9512014-02-11 14:00:19 +0100979 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100980 memprintf(err_msg, "invalid args in conv method '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200981 goto out_error;
982 }
983 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200984 else if (ARGM(conv->arg_mask)) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100985 memprintf(err_msg, "missing args for conv method '%s'", ckw);
Emeric Brun485479d2010-09-23 18:02:19 +0200986 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100987 }
988 }
Emeric Brun485479d2010-09-23 18:02:19 +0200989
Willy Tarreau833cc792013-07-24 15:34:19 +0200990 out:
991 free(fkw);
992 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100993 return expr;
994
995out_error:
Willy Tarreau12785782012-04-27 21:37:17 +0200996 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +0200997 expr = NULL;
998 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +0100999}
1000
1001/*
Willy Tarreau12785782012-04-27 21:37:17 +02001002 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001003 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001004 * Returns a pointer on a typed sample structure containing the result or NULL if
1005 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001006 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001007 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001008 *
1009 * Note: the fetch functions are required to properly set the return type. The
1010 * conversion functions must do so too. However the cast functions do not need
1011 * to since they're made to cast mutiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001012 *
1013 * The caller may indicate in <opt> if it considers the result final or not.
1014 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1015 * if the result is stable or not, according to the following table :
1016 *
1017 * return MAY_CHANGE FINAL Meaning for the sample
1018 * NULL 0 * Not present and will never be (eg: header)
1019 * NULL 1 0 Not present yet, could change (eg: POST param)
1020 * NULL 1 1 Not present yet, will not change anymore
1021 * smp 0 * Present and will not change (eg: header)
1022 * smp 1 0 Present, may change (eg: request length)
1023 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001024 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001025struct sample *sample_process(struct proxy *px, struct session *sess,
1026 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001027 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001028{
Willy Tarreau12785782012-04-27 21:37:17 +02001029 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001030
Willy Tarreau18387e22013-07-25 12:02:38 +02001031 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001032 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001033 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001034 }
Emeric Brun107ca302010-01-04 16:16:05 +01001035
Thierry FOURNIER6879ad32015-05-11 11:54:58 +02001036 p->px = px;
1037 p->sess = sess;
1038 p->strm = strm;
Thierry FOURNIER1d33b882015-05-11 15:25:29 +02001039 p->opt = opt;
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001040 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001041 return NULL;
1042
Emeric Brun107ca302010-01-04 16:16:05 +01001043 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001044 /* we want to ensure that p->type can be casted into
1045 * conv_expr->conv->in_type. We have 3 possibilities :
1046 * - NULL => not castable.
1047 * - c_none => nothing to do (let's optimize it)
1048 * - other => apply cast and prepare to fail
1049 */
Willy Tarreau12785782012-04-27 21:37:17 +02001050 if (!sample_casts[p->type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001051 return NULL;
1052
Willy Tarreau12785782012-04-27 21:37:17 +02001053 if (sample_casts[p->type][conv_expr->conv->in_type] != c_none &&
1054 !sample_casts[p->type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001055 return NULL;
1056
Willy Tarreau12e50112012-04-25 17:21:49 +02001057 /* OK cast succeeded */
1058
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001059 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001060 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001061 }
1062 return p;
1063}
1064
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001065/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001066 * Resolve all remaining arguments in proxy <p>. Returns the number of
1067 * errors or 0 if everything is fine.
1068 */
1069int smp_resolve_args(struct proxy *p)
1070{
1071 struct arg_list *cur, *bak;
1072 const char *ctx, *where;
1073 const char *conv_ctx, *conv_pre, *conv_pos;
1074 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001075 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001076 struct arg *arg;
1077 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001078 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001079
1080 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1081 struct proxy *px;
1082 struct server *srv;
1083 char *pname, *sname;
Willy Tarreau46947782015-01-19 19:00:58 +01001084 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001085
1086 arg = cur->arg;
1087
1088 /* prepare output messages */
1089 conv_pre = conv_pos = conv_ctx = "";
1090 if (cur->conv) {
1091 conv_ctx = cur->conv;
1092 conv_pre = "conversion keyword '";
1093 conv_pos = "' for ";
1094 }
1095
1096 where = "in";
1097 ctx = "sample fetch keyword";
1098 switch (cur->ctx) {
Willy Tarreau46947782015-01-19 19:00:58 +01001099 case ARGC_STK: where = "in stick rule in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001100 case ARGC_TRK: where = "in tracking rule in"; break;
1101 case ARGC_LOG: where = "in log-format string in"; break;
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +01001102 case ARGC_HRQ: where = "in http-request header format string in"; break;
1103 case ARGC_HRS: where = "in http-response header format string in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001104 case ARGC_UIF: where = "in unique-id-format string in"; break;
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +01001105 case ARGC_RDR: where = "in redirect format string in"; break;
Willy Tarreau3a4ac422014-06-13 16:17:14 +02001106 case ARGC_CAP: where = "in capture rule in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001107 case ARGC_ACL: ctx = "ACL keyword"; break;
1108 }
1109
1110 /* set a few default settings */
1111 px = p;
1112 pname = p->id;
1113
1114 switch (arg->type) {
1115 case ARGT_SRV:
1116 if (!arg->data.str.len) {
1117 Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1118 cur->file, cur->line,
1119 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1120 cfgerr++;
1121 continue;
1122 }
1123
1124 /* we support two formats : "bck/srv" and "srv" */
1125 sname = strrchr(arg->data.str.str, '/');
1126
1127 if (sname) {
1128 *sname++ = '\0';
1129 pname = arg->data.str.str;
1130
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001131 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001132 if (!px) {
1133 Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1134 cur->file, cur->line, pname,
1135 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1136 cfgerr++;
1137 break;
1138 }
1139 }
1140 else
1141 sname = arg->data.str.str;
1142
1143 srv = findserver(px, sname);
1144 if (!srv) {
1145 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",
1146 cur->file, cur->line, sname, pname,
1147 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1148 cfgerr++;
1149 break;
1150 }
1151
1152 free(arg->data.str.str);
1153 arg->data.str.str = NULL;
1154 arg->unresolved = 0;
1155 arg->data.srv = srv;
1156 break;
1157
1158 case ARGT_FE:
1159 if (arg->data.str.len) {
1160 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001161 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001162 }
1163
1164 if (!px) {
1165 Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1166 cur->file, cur->line, pname,
1167 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1168 cfgerr++;
1169 break;
1170 }
1171
1172 if (!(px->cap & PR_CAP_FE)) {
1173 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1174 cur->file, cur->line, pname,
1175 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1176 cfgerr++;
1177 break;
1178 }
1179
1180 free(arg->data.str.str);
1181 arg->data.str.str = NULL;
1182 arg->unresolved = 0;
1183 arg->data.prx = px;
1184 break;
1185
1186 case ARGT_BE:
1187 if (arg->data.str.len) {
1188 pname = arg->data.str.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001189 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001190 }
1191
1192 if (!px) {
1193 Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1194 cur->file, cur->line, pname,
1195 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1196 cfgerr++;
1197 break;
1198 }
1199
1200 if (!(px->cap & PR_CAP_BE)) {
1201 Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1202 cur->file, cur->line, pname,
1203 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1204 cfgerr++;
1205 break;
1206 }
1207
1208 free(arg->data.str.str);
1209 arg->data.str.str = NULL;
1210 arg->unresolved = 0;
1211 arg->data.prx = px;
1212 break;
1213
1214 case ARGT_TAB:
1215 if (arg->data.str.len) {
1216 pname = arg->data.str.str;
1217 px = find_stktable(pname);
1218 }
1219
1220 if (!px) {
1221 Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1222 cur->file, cur->line, pname,
1223 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1224 cfgerr++;
1225 break;
1226 }
1227
1228 if (!px->table.size) {
1229 Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1230 cur->file, cur->line, pname,
1231 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1232 cfgerr++;
1233 break;
1234 }
1235
1236 free(arg->data.str.str);
1237 arg->data.str.str = NULL;
1238 arg->unresolved = 0;
1239 arg->data.prx = px;
1240 break;
1241
1242 case ARGT_USR:
1243 if (!arg->data.str.len) {
1244 Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1245 cur->file, cur->line,
1246 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1247 cfgerr++;
1248 break;
1249 }
1250
1251 if (p->uri_auth && p->uri_auth->userlist &&
1252 !strcmp(p->uri_auth->userlist->name, arg->data.str.str))
1253 ul = p->uri_auth->userlist;
1254 else
1255 ul = auth_find_userlist(arg->data.str.str);
1256
1257 if (!ul) {
1258 Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1259 cur->file, cur->line, arg->data.str.str,
1260 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1261 cfgerr++;
1262 break;
1263 }
1264
1265 free(arg->data.str.str);
1266 arg->data.str.str = NULL;
1267 arg->unresolved = 0;
1268 arg->data.usr = ul;
1269 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001270
1271 case ARGT_REG:
1272 if (!arg->data.str.len) {
1273 Alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1274 cur->file, cur->line,
1275 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1276 cfgerr++;
1277 continue;
1278 }
1279
1280 reg = calloc(1, sizeof(*reg));
1281 if (!reg) {
1282 Alert("parsing [%s:%d] : not enough memory to build regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1283 cur->file, cur->line,
1284 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
1285 cfgerr++;
1286 continue;
1287 }
1288
1289 rflags = 0;
1290 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1291 err = NULL;
1292
Willy Tarreaud817e462015-01-23 20:23:17 +01001293 if (!regex_comp(arg->data.str.str, reg, !(rflags & REG_ICASE), 1 /* capture substr */, &err)) {
Willy Tarreau46947782015-01-19 19:00:58 +01001294 Alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1295 cur->file, cur->line,
1296 arg->data.str.str,
1297 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
1298 cfgerr++;
1299 continue;
1300 }
1301
1302 free(arg->data.str.str);
1303 arg->data.str.str = NULL;
1304 arg->unresolved = 0;
1305 arg->data.reg = reg;
1306 break;
1307
1308
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001309 }
1310
1311 LIST_DEL(&cur->list);
1312 free(cur);
1313 } /* end of args processing */
1314
1315 return cfgerr;
1316}
1317
1318/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001319 * Process a fetch + format conversion as defined by the sample expression
1320 * <expr> on request or response considering the <opt> parameter. The output is
1321 * always of type string. If a stable sample can be fetched, or an unstable one
1322 * when <opt> contains SMP_OPT_FINAL, the sample is converted to a string and
1323 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1324 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1325 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1326 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001327 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1328 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1329 * still hope to get it after waiting longer, and is not converted to string.
1330 * The possible output combinations are the following :
1331 *
1332 * return MAY_CHANGE FINAL Meaning for the sample
1333 * NULL * * Not present and will never be (eg: header)
1334 * smp 0 * Final value converted (eg: header)
1335 * smp 1 0 Not present yet, may appear later (eg: header)
1336 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001337 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001338struct sample *sample_fetch_string(struct proxy *px, struct session *sess,
1339 struct stream *strm, unsigned int opt,
1340 struct sample_expr *expr)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001341{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001342 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001343
Willy Tarreau6c616e02014-06-25 16:56:41 +02001344 memset(smp, 0, sizeof(*smp));
1345
Willy Tarreau192252e2015-04-04 01:47:55 +02001346 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001347 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1348 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001349 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001350 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001351
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001352 if (!sample_casts[smp->type][SMP_T_STR])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001353 return NULL;
1354
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001355 if (!sample_casts[smp->type][SMP_T_STR](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001356 return NULL;
1357
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001358 smp->type = SMP_T_STR;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001359 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001360 return smp;
1361}
1362
Emeric Brun107ca302010-01-04 16:16:05 +01001363/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001364/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001365/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001366/*****************************************************************/
1367
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001368static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001369{
1370 struct chunk *trash = get_trash_chunk();
1371 int b64_len;
1372
1373 trash->len = 0;
1374 b64_len = a2base64(smp->data.str.str, smp->data.str.len, trash->str, trash->size);
1375 if (b64_len < 0)
1376 return 0;
1377
1378 trash->len = b64_len;
1379 smp->data.str = *trash;
1380 smp->type = SMP_T_STR;
1381 smp->flags &= ~SMP_F_CONST;
1382 return 1;
1383}
1384
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001385static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001386{
1387 struct chunk *trash = get_trash_chunk();
1388 unsigned char c;
1389 int ptr = 0;
1390
1391 trash->len = 0;
1392 while (ptr < smp->data.str.len && trash->len <= trash->size - 2) {
1393 c = smp->data.str.str[ptr++];
1394 trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
1395 trash->str[trash->len++] = hextab[c & 0xF];
1396 }
1397 smp->data.str = *trash;
1398 smp->type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001399 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001400 return 1;
1401}
1402
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001403/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001404static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001405{
1406 smp->data.uint = hash_djb2(smp->data.str.str, smp->data.str.len);
1407 if (arg_p && arg_p->data.uint)
1408 smp->data.uint = full_hash(smp->data.uint);
1409 smp->type = SMP_T_UINT;
1410 return 1;
1411}
1412
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001413static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001414{
1415 int i;
1416
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001417 if (!smp_dup(smp))
1418 return 0;
1419
Willy Tarreau342acb42012-04-23 22:03:39 +02001420 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001421 return 0;
1422
Willy Tarreau342acb42012-04-23 22:03:39 +02001423 for (i = 0; i < smp->data.str.len; i++) {
1424 if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z'))
1425 smp->data.str.str[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001426 }
1427 return 1;
1428}
1429
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001430static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001431{
1432 int i;
1433
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001434 if (!smp_dup(smp))
1435 return 0;
1436
Willy Tarreau342acb42012-04-23 22:03:39 +02001437 if (!smp->data.str.size)
Emeric Brun485479d2010-09-23 18:02:19 +02001438 return 0;
1439
Willy Tarreau342acb42012-04-23 22:03:39 +02001440 for (i = 0; i < smp->data.str.len; i++) {
1441 if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z'))
1442 smp->data.str.str[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001443 }
1444 return 1;
1445}
1446
Willy Tarreauf9954102012-04-20 14:03:29 +02001447/* takes the netmask in arg_p */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001448static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001449{
Willy Tarreau342acb42012-04-23 22:03:39 +02001450 smp->data.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001451 smp->type = SMP_T_IPV4;
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001452 return 1;
1453}
1454
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001455/* takes an UINT value on input supposed to represent the time since EPOCH,
1456 * adds an optional offset found in args[1] and emits a string representing
1457 * the local time in the format specified in args[1] using strftime().
1458 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001459static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001460{
1461 struct chunk *temp;
1462 time_t curr_date = smp->data.uint;
1463
1464 /* add offset */
1465 if (args[1].type == ARGT_SINT || args[1].type == ARGT_UINT)
1466 curr_date += args[1].data.sint;
1467
1468 temp = get_trash_chunk();
1469 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, localtime(&curr_date));
1470 smp->data.str = *temp;
1471 smp->type = SMP_T_STR;
1472 return 1;
1473}
1474
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001475/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001476static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001477{
1478 smp->data.uint = hash_sdbm(smp->data.str.str, smp->data.str.len);
1479 if (arg_p && arg_p->data.uint)
1480 smp->data.uint = full_hash(smp->data.uint);
1481 smp->type = SMP_T_UINT;
1482 return 1;
1483}
1484
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001485/* takes an UINT value on input supposed to represent the time since EPOCH,
1486 * adds an optional offset found in args[1] and emits a string representing
1487 * the UTC date in the format specified in args[1] using strftime().
1488 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001489static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001490{
1491 struct chunk *temp;
1492 time_t curr_date = smp->data.uint;
1493
1494 /* add offset */
1495 if (args[1].type == ARGT_SINT || args[1].type == ARGT_UINT)
1496 curr_date += args[1].data.sint;
1497
1498 temp = get_trash_chunk();
1499 temp->len = strftime(temp->str, temp->size, args[0].data.str.str, gmtime(&curr_date));
1500 smp->data.str = *temp;
1501 smp->type = SMP_T_STR;
1502 return 1;
1503}
1504
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001505/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001506static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001507{
1508 smp->data.uint = hash_wt6(smp->data.str.str, smp->data.str.len);
1509 if (arg_p && arg_p->data.uint)
1510 smp->data.uint = full_hash(smp->data.uint);
1511 smp->type = SMP_T_UINT;
1512 return 1;
1513}
1514
Willy Tarreau80599772015-01-20 19:35:24 +01001515/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001516static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01001517{
1518 smp->data.uint = hash_crc32(smp->data.str.str, smp->data.str.len);
1519 if (arg_p && arg_p->data.uint)
1520 smp->data.uint = full_hash(smp->data.uint);
1521 smp->type = SMP_T_UINT;
1522 return 1;
1523}
1524
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001525/* This function escape special json characters. The returned string can be
1526 * safely set between two '"' and used as json string. The json string is
1527 * defined like this:
1528 *
1529 * any Unicode character except '"' or '\' or control character
1530 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
1531 *
1532 * The enum input_type contain all the allowed mode for decoding the input
1533 * string.
1534 */
1535enum input_type {
1536 IT_ASCII = 0,
1537 IT_UTF8,
1538 IT_UTF8S,
1539 IT_UTF8P,
1540 IT_UTF8PS,
1541};
1542static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
1543 const char *file, int line, char **err)
1544{
1545 if (!arg) {
1546 memprintf(err, "Unexpected empty arg list");
1547 return 0;
1548 }
1549
1550 if (arg->type != ARGT_STR) {
1551 memprintf(err, "Unexpected arg type");
1552 return 0;
1553 }
1554
1555 if (strcmp(arg->data.str.str, "") == 0) {
1556 arg->type = ARGT_UINT;
1557 arg->data.uint = IT_ASCII;
1558 return 1;
1559 }
1560
1561 else if (strcmp(arg->data.str.str, "ascii") == 0) {
1562 arg->type = ARGT_UINT;
1563 arg->data.uint = IT_ASCII;
1564 return 1;
1565 }
1566
1567 else if (strcmp(arg->data.str.str, "utf8") == 0) {
1568 arg->type = ARGT_UINT;
1569 arg->data.uint = IT_UTF8;
1570 return 1;
1571 }
1572
1573 else if (strcmp(arg->data.str.str, "utf8s") == 0) {
1574 arg->type = ARGT_UINT;
1575 arg->data.uint = IT_UTF8S;
1576 return 1;
1577 }
1578
1579 else if (strcmp(arg->data.str.str, "utf8p") == 0) {
1580 arg->type = ARGT_UINT;
1581 arg->data.uint = IT_UTF8P;
1582 return 1;
1583 }
1584
1585 else if (strcmp(arg->data.str.str, "utf8ps") == 0) {
1586 arg->type = ARGT_UINT;
1587 arg->data.uint = IT_UTF8PS;
1588 return 1;
1589 }
1590
1591 memprintf(err, "Unexpected input code type at file '%s', line %d. "
1592 "Allowed value are 'ascii', 'utf8', 'utf8p' and 'utf8pp'", file, line);
1593 return 0;
1594}
1595
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001596static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001597{
1598 struct chunk *temp;
1599 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
1600 const char *str;
1601 int len;
1602 enum input_type input_type = IT_ASCII;
1603 unsigned int c;
1604 unsigned int ret;
1605 char *p;
1606
1607 if (arg_p)
1608 input_type = arg_p->data.uint;
1609
1610 temp = get_trash_chunk();
1611 temp->len = 0;
1612
1613 p = smp->data.str.str;
1614 while (p < smp->data.str.str + smp->data.str.len) {
1615
1616 if (input_type == IT_ASCII) {
1617 /* Read input as ASCII. */
1618 c = *(unsigned char *)p;
1619 p++;
1620 }
1621 else {
1622 /* Read input as UTF8. */
1623 ret = utf8_next(p, smp->data.str.len - ( p - smp->data.str.str ), &c);
1624 p += utf8_return_length(ret);
1625
1626 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
1627 return 0;
1628 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
1629 continue;
1630 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1631 return 0;
1632 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
1633 continue;
1634
1635 /* Check too big values. */
1636 if ((unsigned int)c > 0xffff) {
1637 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
1638 return 0;
1639 continue;
1640 }
1641 }
1642
1643 /* Convert character. */
1644 if (c == '"') {
1645 len = 2;
1646 str = "\\\"";
1647 }
1648 else if (c == '\\') {
1649 len = 2;
1650 str = "\\\\";
1651 }
1652 else if (c == '/') {
1653 len = 2;
1654 str = "\\/";
1655 }
1656 else if (c == '\b') {
1657 len = 2;
1658 str = "\\b";
1659 }
1660 else if (c == '\f') {
1661 len = 2;
1662 str = "\\f";
1663 }
1664 else if (c == '\r') {
1665 len = 2;
1666 str = "\\r";
1667 }
1668 else if (c == '\n') {
1669 len = 2;
1670 str = "\\n";
1671 }
1672 else if (c == '\t') {
1673 len = 2;
1674 str = "\\t";
1675 }
1676 else if (c > 0xff || !isprint(c)) {
1677 /* isprint generate a segfault if c is too big. The man says that
1678 * c must have the value of an unsigned char or EOF.
1679 */
1680 len = 6;
1681 _str[0] = '\\';
1682 _str[1] = 'u';
1683 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
1684 str = _str;
1685 }
1686 else {
1687 len = 1;
1688 str = (char *)&c;
1689 }
1690
1691 /* Check length */
1692 if (temp->len + len > temp->size)
1693 return 0;
1694
1695 /* Copy string. */
1696 memcpy(temp->str + temp->len, str, len);
1697 temp->len += len;
1698 }
1699
1700 smp->flags &= ~SMP_F_CONST;
1701 smp->data.str = *temp;
1702 smp->type = SMP_T_STR;
1703
1704 return 1;
1705}
1706
Emeric Brun54c4ac82014-11-03 15:32:43 +01001707/* This sample function is designed to extract some bytes from an input buffer.
1708 * First arg is the offset.
1709 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001710static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01001711{
1712 if (smp->data.str.len <= arg_p[0].data.uint) {
1713 smp->data.str.len = 0;
1714 return 1;
1715 }
1716
1717 if (smp->data.str.size)
1718 smp->data.str.size -= arg_p[0].data.uint;
1719 smp->data.str.len -= arg_p[0].data.uint;
1720 smp->data.str.str += arg_p[0].data.uint;
1721
1722 if ((arg_p[1].type == ARGT_UINT) && (arg_p[1].data.uint < smp->data.str.len))
1723 smp->data.str.len = arg_p[1].data.uint;
1724
1725 return 1;
1726}
1727
Emeric Brunf399b0d2014-11-03 17:07:03 +01001728static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
1729 const char *file, int line, char **err)
1730{
1731 struct arg *arg = args;
1732
1733 if (!arg) {
1734 memprintf(err, "Unexpected empty arg list");
1735 return 0;
1736 }
1737
1738 if (arg->type != ARGT_UINT) {
1739 memprintf(err, "Unexpected arg type");
1740 return 0;
1741 }
1742
1743 if (!arg->data.uint) {
1744 memprintf(err, "Unexpected value 0 for index");
1745 return 0;
1746 }
1747
1748 arg++;
1749
1750 if (arg->type != ARGT_STR) {
1751 memprintf(err, "Unexpected arg type");
1752 return 0;
1753 }
1754
1755 if (!arg->data.str.len) {
1756 memprintf(err, "Empty separators list");
1757 return 0;
1758 }
1759
1760 return 1;
1761}
1762
1763/* This sample function is designed to a return selected part of a string (field).
1764 * First arg is the index of the field (start at 1)
1765 * Second arg is a char list of separators (type string)
1766 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001767static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01001768{
1769 unsigned int field;
1770 char *start, *end;
1771 int i;
1772
1773 if (!arg_p[0].data.uint)
1774 return 0;
1775
1776 field = 1;
1777 end = start = smp->data.str.str;
1778 while (end - smp->data.str.str < smp->data.str.len) {
1779
1780 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
1781 if (*end == arg_p[1].data.str.str[i]) {
1782 if (field == arg_p[0].data.uint)
1783 goto found;
1784 start = end+1;
1785 field++;
1786 break;
1787 }
1788 }
1789 end++;
1790 }
1791
1792 /* Field not found */
1793 if (field != arg_p[0].data.uint) {
1794 smp->data.str.len = 0;
1795 return 1;
1796 }
1797found:
1798 smp->data.str.len = end - start;
1799 /* If ret string is len 0, no need to
1800 change pointers or to update size */
1801 if (!smp->data.str.len)
1802 return 1;
1803
1804 smp->data.str.str = start;
1805
1806 /* Compute remaining size if needed
1807 Note: smp->data.str.size cannot be set to 0 */
1808 if (smp->data.str.size)
1809 smp->data.str.size -= start - smp->data.str.str;
1810
1811 return 1;
1812}
1813
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001814/* This sample function is designed to return a word from a string.
1815 * First arg is the index of the word (start at 1)
1816 * Second arg is a char list of words separators (type string)
1817 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001818static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01001819{
1820 unsigned int word;
1821 char *start, *end;
1822 int i, issep, inword;
1823
1824 if (!arg_p[0].data.uint)
1825 return 0;
1826
1827 word = 0;
1828 inword = 0;
1829 end = start = smp->data.str.str;
1830 while (end - smp->data.str.str < smp->data.str.len) {
1831 issep = 0;
1832 for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
1833 if (*end == arg_p[1].data.str.str[i]) {
1834 issep = 1;
1835 break;
1836 }
1837 }
1838 if (!inword) {
1839 if (!issep) {
1840 word++;
1841 start = end;
1842 inword = 1;
1843 }
1844 }
1845 else if (issep) {
1846 if (word == arg_p[0].data.uint)
1847 goto found;
1848 inword = 0;
1849 }
1850 end++;
1851 }
1852
1853 /* Field not found */
1854 if (word != arg_p[0].data.uint) {
1855 smp->data.str.len = 0;
1856 return 1;
1857 }
1858found:
1859 smp->data.str.len = end - start;
1860 /* If ret string is len 0, no need to
1861 change pointers or to update size */
1862 if (!smp->data.str.len)
1863 return 1;
1864
1865 smp->data.str.str = start;
1866
1867 /* Compute remaining size if needed
1868 Note: smp->data.str.size cannot be set to 0 */
1869 if (smp->data.str.size)
1870 smp->data.str.size -= start - smp->data.str.str;
1871
1872 return 1;
1873}
1874
Willy Tarreau7eda8492015-01-20 19:47:06 +01001875static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
1876 const char *file, int line, char **err)
1877{
1878 struct arg *arg = args;
1879 char *p;
1880 int len;
1881
1882 /* arg0 is a regex, it uses type_flag for ICASE and global match */
1883 arg[0].type_flags = 0;
1884
1885 if (arg[2].type != ARGT_STR)
1886 return 1;
1887
1888 p = arg[2].data.str.str;
1889 len = arg[2].data.str.len;
1890 while (len) {
1891 if (*p == 'i') {
1892 arg[0].type_flags |= ARGF_REG_ICASE;
1893 }
1894 else if (*p == 'g') {
1895 arg[0].type_flags |= ARGF_REG_GLOB;
1896 }
1897 else {
1898 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
1899 return 0;
1900 }
1901 p++;
1902 len--;
1903 }
1904 return 1;
1905}
1906
1907/* This sample function is designed to do the equivalent of s/match/replace/ on
1908 * the input string. It applies a regex and restarts from the last matched
1909 * location until nothing matches anymore. First arg is the regex to apply to
1910 * the input string, second arg is the replacement expression.
1911 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001912static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01001913{
1914 char *start, *end;
1915 struct my_regex *reg = arg_p[0].data.reg;
1916 regmatch_t pmatch[MAX_MATCH];
1917 struct chunk *trash = get_trash_chunk();
1918 int flag, max;
1919 int found;
1920
1921 start = smp->data.str.str;
1922 end = start + smp->data.str.len;
1923
1924 flag = 0;
1925 while (1) {
1926 /* check for last round which is used to copy remaining parts
1927 * when not running in global replacement mode.
1928 */
1929 found = 0;
1930 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
1931 /* Note: we can have start == end on empty strings or at the end */
1932 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
1933 }
1934
1935 if (!found)
1936 pmatch[0].rm_so = end - start;
1937
1938 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
1939 max = trash->size - trash->len;
1940 if (max && pmatch[0].rm_so > 0) {
1941 if (max > pmatch[0].rm_so)
1942 max = pmatch[0].rm_so;
1943 memcpy(trash->str + trash->len, start, max);
1944 trash->len += max;
1945 }
1946
1947 if (!found)
1948 break;
1949
1950 /* replace the matching part */
1951 max = trash->size - trash->len;
1952 if (max) {
1953 if (max > arg_p[1].data.str.len)
1954 max = arg_p[1].data.str.len;
1955 memcpy(trash->str + trash->len, arg_p[1].data.str.str, max);
1956 trash->len += max;
1957 }
1958
1959 /* stop here if we're done with this string */
1960 if (start >= end)
1961 break;
1962
1963 /* We have a special case for matches of length 0 (eg: "x*y*").
1964 * These ones are considered to match in front of a character,
1965 * so we have to copy that character and skip to the next one.
1966 */
1967 if (!pmatch[0].rm_eo) {
1968 if (trash->len < trash->size)
1969 trash->str[trash->len++] = start[pmatch[0].rm_eo];
1970 pmatch[0].rm_eo++;
1971 }
1972
1973 start += pmatch[0].rm_eo;
1974 flag |= REG_NOTBOL;
1975 }
1976
1977 smp->data.str = *trash;
1978 return 1;
1979}
1980
Willy Tarreau97707872015-01-27 15:12:13 +01001981/* Takes a UINT on input, applies a binary twos complement and returns the UINT
1982 * result.
1983 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001984static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01001985{
1986 smp->data.uint = ~smp->data.uint;
1987 return 1;
1988}
1989
1990/* Takes a UINT on input, applies a binary "and" with the UINT in arg_p, and
1991 * returns the UINT result.
1992 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001993static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01001994{
1995 smp->data.uint &= arg_p->data.uint;
1996 return 1;
1997}
1998
1999/* Takes a UINT on input, applies a binary "or" with the UINT in arg_p, and
2000 * returns the UINT result.
2001 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002002static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002003{
2004 smp->data.uint |= arg_p->data.uint;
2005 return 1;
2006}
2007
2008/* Takes a UINT on input, applies a binary "xor" with the UINT in arg_p, and
2009 * returns the UINT result.
2010 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002011static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002012{
2013 smp->data.uint ^= arg_p->data.uint;
2014 return 1;
2015}
2016
2017/* Takes a UINT on input, applies an arithmetic "add" with the UINT in arg_p,
2018 * and returns the UINT result.
2019 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002020static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002021{
2022 smp->data.uint += arg_p->data.uint;
2023 return 1;
2024}
2025
2026/* Takes a UINT on input, applies an arithmetic "sub" with the UINT in arg_p,
2027 * and returns the UINT result.
2028 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002029static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002030 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002031{
2032 smp->data.uint -= arg_p->data.uint;
2033 return 1;
2034}
2035
2036/* Takes a UINT on input, applies an arithmetic "mul" with the UINT in arg_p,
2037 * and returns the UINT result.
2038 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002039static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002040 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002041{
2042 smp->data.uint *= arg_p->data.uint;
2043 return 1;
2044}
2045
2046/* Takes a UINT on input, applies an arithmetic "div" with the UINT in arg_p,
2047 * and returns the UINT result. If arg_p makes the result overflow, then the
2048 * largest possible quantity is returned.
2049 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002050static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002051 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002052{
2053 if (arg_p->data.uint)
2054 smp->data.uint /= arg_p->data.uint;
2055 else
2056 smp->data.uint = ~0;
2057 return 1;
2058}
2059
2060/* Takes a UINT on input, applies an arithmetic "mod" with the UINT in arg_p,
2061 * and returns the UINT result. If arg_p makes the result overflow, then zero
2062 * is returned.
2063 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002064static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002065 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002066{
2067 if (arg_p->data.uint)
2068 smp->data.uint %= arg_p->data.uint;
2069 else
2070 smp->data.uint = 0;
2071 return 1;
2072}
2073
2074/* Takes an UINT on input, applies an arithmetic "neg" and returns the UINT
2075 * result.
2076 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002077static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002078 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002079{
2080 smp->data.uint = -smp->data.uint;
2081 return 1;
2082}
2083
2084/* Takes a UINT on input, returns true is the value is non-null, otherwise
2085 * false. The output is a BOOL.
2086 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002087static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002088 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002089{
2090 smp->data.uint = !!smp->data.uint;
2091 smp->type = SMP_T_BOOL;
2092 return 1;
2093}
2094
2095/* Takes a UINT on input, returns false is the value is non-null, otherwise
2096 * truee. The output is a BOOL.
2097 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002098static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002099 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002100{
2101 smp->data.uint = !smp->data.uint;
2102 smp->type = SMP_T_BOOL;
2103 return 1;
2104}
2105
2106/* Takes a UINT on input, returns true is the value is odd, otherwise false.
2107 * The output is a BOOL.
2108 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002109static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002110 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002111{
2112 smp->data.uint = smp->data.uint & 1;
2113 smp->type = SMP_T_BOOL;
2114 return 1;
2115}
2116
2117/* Takes a UINT on input, returns true is the value is even, otherwise false.
2118 * The output is a BOOL.
2119 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002120static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002121 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002122{
2123 smp->data.uint = !(smp->data.uint & 1);
2124 smp->type = SMP_T_BOOL;
2125 return 1;
2126}
2127
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002128/************************************************************************/
2129/* All supported sample fetch functions must be declared here */
2130/************************************************************************/
2131
2132/* force TRUE to be returned at the fetch level */
2133static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002134smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002135{
2136 smp->type = SMP_T_BOOL;
2137 smp->data.uint = 1;
2138 return 1;
2139}
2140
2141/* force FALSE to be returned at the fetch level */
2142static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002143smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002144{
2145 smp->type = SMP_T_BOOL;
2146 smp->data.uint = 0;
2147 return 1;
2148}
2149
2150/* retrieve environment variable $1 as a string */
2151static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002152smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002153{
2154 char *env;
2155
2156 if (!args || args[0].type != ARGT_STR)
2157 return 0;
2158
2159 env = getenv(args[0].data.str.str);
2160 if (!env)
2161 return 0;
2162
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002163 smp->type = SMP_T_STR;
2164 smp->flags = SMP_F_CONST;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002165 smp->data.str.str = env;
2166 smp->data.str.len = strlen(env);
2167 return 1;
2168}
2169
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002170/* retrieve the current local date in epoch time, and applies an optional offset
2171 * of args[0] seconds.
2172 */
2173static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002174smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002175{
2176 smp->data.uint = date.tv_sec;
2177
2178 /* add offset */
2179 if (args && (args[0].type == ARGT_SINT || args[0].type == ARGT_UINT))
2180 smp->data.uint += args[0].data.sint;
2181
2182 smp->type = SMP_T_UINT;
2183 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2184 return 1;
2185}
2186
Willy Tarreau0f30d262014-11-24 16:02:05 +01002187/* returns the number of processes */
2188static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002189smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002190{
2191 smp->type = SMP_T_UINT;
2192 smp->data.uint = global.nbproc;
2193 return 1;
2194}
2195
2196/* returns the number of the current process (between 1 and nbproc */
2197static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002198smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002199{
2200 smp->type = SMP_T_UINT;
2201 smp->data.uint = relative_pid;
2202 return 1;
2203}
2204
Willy Tarreau84310e22014-02-14 11:59:04 +01002205/* generate a random 32-bit integer for whatever purpose, with an optional
2206 * range specified in argument.
2207 */
2208static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002209smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01002210{
2211 smp->data.uint = random();
2212
2213 /* reduce if needed. Don't do a modulo, use all bits! */
2214 if (args && args[0].type == ARGT_UINT)
Vincent Bernat1228dc02014-12-10 10:31:37 +01002215 smp->data.uint = ((uint64_t)smp->data.uint * args[0].data.uint) / ((u64)RAND_MAX+1);
Willy Tarreau84310e22014-02-14 11:59:04 +01002216
2217 smp->type = SMP_T_UINT;
2218 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
2219 return 1;
2220}
2221
Willy Tarreau0f30d262014-11-24 16:02:05 +01002222/* returns true if the current process is stopping */
2223static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002224smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01002225{
2226 smp->type = SMP_T_BOOL;
2227 smp->data.uint = stopping;
2228 return 1;
2229}
2230
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002231/* Note: must not be declared <const> as its list will be overwritten.
2232 * Note: fetches that may return multiple types must be declared as the lowest
2233 * common denominator, the type that can be casted into all other ones. For
2234 * instance IPv4/IPv6 must be declared IPv4.
2235 */
2236static struct sample_fetch_kw_list smp_kws = {ILH, {
2237 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
2238 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002239 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau6236d3a2013-07-25 14:28:25 +02002240 { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01002241 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_UINT, SMP_USE_INTRN },
2242 { "proc", smp_fetch_proc, 0, NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau84310e22014-02-14 11:59:04 +01002243 { "rand", smp_fetch_rand, ARG1(0,UINT), NULL, SMP_T_UINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01002244 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002245 { /* END */ },
2246}};
2247
Emeric Brun107ca302010-01-04 16:16:05 +01002248/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02002249static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Emeric Brun53d1a982014-04-30 18:21:37 +02002250 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002251 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
2252 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002253 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02002254 { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 },
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002255 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_UINT, SMP_T_STR },
2256 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_UINT, SMP_T_STR },
Willy Tarreau80599772015-01-20 19:35:24 +01002257 { "crc32", sample_conv_crc32, ARG1(0,UINT), NULL, SMP_T_BIN, SMP_T_UINT },
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002258 { "djb2", sample_conv_djb2, ARG1(0,UINT), NULL, SMP_T_BIN, SMP_T_UINT },
2259 { "sdbm", sample_conv_sdbm, ARG1(0,UINT), NULL, SMP_T_BIN, SMP_T_UINT },
2260 { "wt6", sample_conv_wt6, ARG1(0,UINT), NULL, SMP_T_BIN, SMP_T_UINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002261 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Emeric Brun54c4ac82014-11-03 15:32:43 +01002262 { "bytes", sample_conv_bytes, ARG2(1,UINT,UINT), NULL, SMP_T_BIN, SMP_T_BIN },
Emeric Brunf399b0d2014-11-03 17:07:03 +01002263 { "field", sample_conv_field, ARG2(2,UINT,STR), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002264 { "word", sample_conv_word, ARG2(2,UINT,STR), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
Willy Tarreau7eda8492015-01-20 19:47:06 +01002265 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
Willy Tarreau97707872015-01-27 15:12:13 +01002266
2267 { "and", sample_conv_binary_and, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2268 { "or", sample_conv_binary_or, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2269 { "xor", sample_conv_binary_xor, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2270 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_UINT, SMP_T_UINT },
2271 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_UINT, SMP_T_BOOL },
2272 { "not", sample_conv_arith_not, 0, NULL, SMP_T_UINT, SMP_T_BOOL },
2273 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_UINT, SMP_T_BOOL },
2274 { "even", sample_conv_arith_even, 0, NULL, SMP_T_UINT, SMP_T_BOOL },
2275 { "add", sample_conv_arith_add, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2276 { "sub", sample_conv_arith_sub, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2277 { "mul", sample_conv_arith_mul, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2278 { "div", sample_conv_arith_div, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2279 { "mod", sample_conv_arith_mod, ARG1(1,UINT), NULL, SMP_T_UINT, SMP_T_UINT },
2280 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_UINT, SMP_T_UINT },
2281
Willy Tarreau9fcb9842012-04-20 14:45:49 +02002282 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01002283}};
2284
2285__attribute__((constructor))
Willy Tarreau12785782012-04-27 21:37:17 +02002286static void __sample_init(void)
Emeric Brun107ca302010-01-04 16:16:05 +01002287{
Willy Tarreau5b8ad222013-07-25 12:17:57 +02002288 /* register sample fetch and format conversion keywords */
2289 sample_register_fetches(&smp_kws);
Willy Tarreau12785782012-04-27 21:37:17 +02002290 sample_register_convs(&sample_conv_kws);
Emeric Brun107ca302010-01-04 16:16:05 +01002291}