blob: 0715e146898c103111f963df7a994a7d6ef667c9 [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 Tarreau4c7e4b72020-05-27 12:58:42 +020019#include <haproxy/api.h>
Willy Tarreau7e2c6472012-10-29 20:44:36 +010020#include <types/global.h>
21
Willy Tarreauc7e42382012-08-24 19:22:53 +020022#include <common/chunk.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020023#include <haproxy/hash.h>
Willy Tarreau35b51c62018-09-10 15:38:55 +020024#include <common/http.h>
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +010025#include <common/net_helper.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020026#include <common/standard.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020027#include <common/uri_auth.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020028#include <haproxy/base64.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020029
Willy Tarreau9fcb9842012-04-20 14:45:49 +020030#include <proto/arg.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020031#include <proto/auth.h>
32#include <proto/log.h>
33#include <proto/proxy.h>
Frédéric Lécaillefd95c622019-02-26 14:09:08 +010034#include <proto/protocol_buffers.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020035#include <proto/sample.h>
Willy Tarreau0851fd52019-12-17 10:07:25 +010036#include <proto/sink.h>
Willy Tarreaua4312fa2013-04-02 16:34:32 +020037#include <proto/stick_table.h>
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +020038#include <proto/vars.h>
Emeric Brun107ca302010-01-04 16:16:05 +010039
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +020040#include <import/sha1.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010041#include <import/xxhash.h>
42
Willy Tarreau1cf8f082014-02-07 12:14:54 +010043/* sample type names */
44const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020045 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010046 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010047 [SMP_T_SINT] = "sint",
48 [SMP_T_ADDR] = "addr",
49 [SMP_T_IPV4] = "ipv4",
50 [SMP_T_IPV6] = "ipv6",
51 [SMP_T_STR] = "str",
52 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020053 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010054};
55
Willy Tarreau12785782012-04-27 21:37:17 +020056/* static sample used in sample_process() when <p> is NULL */
Emeric Brune5c918b2017-06-14 14:15:36 +020057static THREAD_LOCAL struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010058
Willy Tarreau12785782012-04-27 21:37:17 +020059/* list head of all known sample fetch keywords */
60static struct sample_fetch_kw_list sample_fetches = {
61 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010062};
63
Willy Tarreau12785782012-04-27 21:37:17 +020064/* list head of all known sample format conversion keywords */
65static struct sample_conv_kw_list sample_convs = {
66 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010067};
68
Willy Tarreau80aca902013-01-07 15:42:20 +010069const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
70 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
71 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
72 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
73 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
74 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
75 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010076 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +010077
78 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
79 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
80 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
81 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
82 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
83 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010084 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010085
86 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
87 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
88 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
89 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
90 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
91 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010092 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010093
94 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
95 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
96 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
97 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
98 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
99 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100100 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100101
102 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
103 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
104 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
105 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
106 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
107 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100108 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100109
110 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
111 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
112 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
113 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
114 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
115 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100116 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100117
118 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
119 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
120 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
121 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
122 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
123 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100124 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100125
126 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
127 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
128 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
129 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
130 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
131 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100132 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100133
134 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
135 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
136 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
137 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
138 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
139 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100140 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100141
142 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
143 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
144 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
145 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
146 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
147 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100148 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100149
150 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
151 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
152 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
153 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
154 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
155 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100156 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100157
158 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
159 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
160 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
161 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
162 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
163 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100164 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100165
166 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
167 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
168 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
169 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
170 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
171 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100172 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100173
174 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
175 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
176 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
177 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
178 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
179 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100180 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100181
182 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
183 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
184 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
185 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
186 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
187 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200188 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100189
190 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
191 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
192 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
193 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
194 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
195 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200196 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100197
198 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
199 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
200 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
201 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
202 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
203 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200204 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100205
206 [SMP_SRC_HRSBO] = (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_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
211 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200212 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100213
214 [SMP_SRC_RQFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100220 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100221
222 [SMP_SRC_RSFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100228 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100229
230 [SMP_SRC_TXFIN] = (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___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100236 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100237
238 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
239 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
240 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
241 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
242 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
243 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100244 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100245};
246
247static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
248 [SMP_SRC_INTRN] = "internal state",
249 [SMP_SRC_LISTN] = "listener",
250 [SMP_SRC_FTEND] = "frontend",
251 [SMP_SRC_L4CLI] = "client address",
252 [SMP_SRC_L5CLI] = "client-side connection",
253 [SMP_SRC_TRACK] = "track counters",
254 [SMP_SRC_L6REQ] = "request buffer",
255 [SMP_SRC_HRQHV] = "HTTP request headers",
256 [SMP_SRC_HRQHP] = "HTTP request",
257 [SMP_SRC_HRQBO] = "HTTP request body",
258 [SMP_SRC_BKEND] = "backend",
259 [SMP_SRC_SERVR] = "server",
260 [SMP_SRC_L4SRV] = "server address",
261 [SMP_SRC_L5SRV] = "server-side connection",
262 [SMP_SRC_L6RES] = "response buffer",
263 [SMP_SRC_HRSHV] = "HTTP response headers",
264 [SMP_SRC_HRSHP] = "HTTP response",
265 [SMP_SRC_HRSBO] = "HTTP response body",
266 [SMP_SRC_RQFIN] = "request buffer statistics",
267 [SMP_SRC_RSFIN] = "response buffer statistics",
268 [SMP_SRC_TXFIN] = "transaction statistics",
269 [SMP_SRC_SSFIN] = "session statistics",
270};
271
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100272static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
273 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
274 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
275 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
276 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
277 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
278 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
279 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
280 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
281 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
282 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
283 [SMP_CKP_BE_SRV_CON] = "server source selection",
284 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
285 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
286 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
287 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
288 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
289 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
290 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
291 [SMP_CKP_FE_LOG_END] = "logs",
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100292 [SMP_CKP_BE_CHK_RUL] = "backend tcp-check rule",
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100293};
294
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100295/* This function returns the type of the data returned by the sample_expr.
296 * It assumes that the <expr> and all of its converters are properly
297 * initialized.
298 */
299inline
300int smp_expr_output_type(struct sample_expr *expr)
301{
302 struct sample_conv_expr *smp_expr;
303
304 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
305 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
306 return smp_expr->conv->out_type;
307 }
308 return expr->fetch->out_type;
309}
310
311
Willy Tarreau80aca902013-01-07 15:42:20 +0100312/* fill the trash with a comma-delimited list of source names for the <use> bit
313 * field which must be composed of a non-null set of SMP_USE_* flags. The return
314 * value is the pointer to the string in the trash buffer.
315 */
316const char *sample_src_names(unsigned int use)
317{
318 int bit;
319
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200320 trash.data = 0;
321 trash.area[0] = '\0';
Willy Tarreau80aca902013-01-07 15:42:20 +0100322 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
323 if (!(use & ~((1 << bit) - 1)))
324 break; /* no more bits */
325
326 if (!(use & (1 << bit)))
327 continue; /* bit not set */
328
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200329 trash.data += snprintf(trash.area + trash.data,
330 trash.size - trash.data, "%s%s",
331 (use & ((1 << bit) - 1)) ? "," : "",
332 fetch_src_names[bit]);
Willy Tarreau80aca902013-01-07 15:42:20 +0100333 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200334 return trash.area;
Willy Tarreau80aca902013-01-07 15:42:20 +0100335}
336
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100337/* return a pointer to the correct sample checkpoint name, or "unknown" when
338 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
339 * if set.
340 */
341const char *sample_ckp_names(unsigned int use)
342{
343 int bit;
344
345 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
346 if (use & (1 << bit))
347 return fetch_ckp_names[bit];
348 return "unknown sample check place, please report this bug";
349}
350
Emeric Brun107ca302010-01-04 16:16:05 +0100351/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100352 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
353 * for next parsing sessions. The fetch keywords capabilities are also computed
354 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100355 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100356void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100357{
Willy Tarreau80aca902013-01-07 15:42:20 +0100358 struct sample_fetch *sf;
359 int bit;
360
361 for (sf = kwl->kw; sf->kw != NULL; sf++) {
362 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
363 if (sf->use & (1 << bit))
364 sf->val |= fetch_cap[bit];
365 }
366 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100367}
368
369/*
Willy Tarreau12785782012-04-27 21:37:17 +0200370 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100371 * parsing sessions.
372 */
Willy Tarreau12785782012-04-27 21:37:17 +0200373void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100374{
Willy Tarreau12785782012-04-27 21:37:17 +0200375 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100376}
377
378/*
Willy Tarreau12785782012-04-27 21:37:17 +0200379 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100380 * string of <len> in buffer <kw>.
381 *
382 */
Willy Tarreau12785782012-04-27 21:37:17 +0200383struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100384{
385 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200386 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100387
Willy Tarreau12785782012-04-27 21:37:17 +0200388 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100389 for (index = 0; kwl->kw[index].kw != NULL; index++) {
390 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
391 kwl->kw[index].kw[len] == '\0')
392 return &kwl->kw[index];
393 }
394 }
395 return NULL;
396}
397
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100398/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100399 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100400 * <idx> is the index of the next sample fetch entry. It is used as private
401 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100402 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100403 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100404 * the list is reached.
405 */
406struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
407{
408 struct sample_fetch_kw_list *kwl;
409 struct sample_fetch *base;
410
411 if (!current) {
412 /* Get first kwl entry. */
413 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
414 (*idx) = 0;
415 } else {
416 /* Get kwl corresponding to the curret entry. */
417 base = current + 1 - (*idx);
418 kwl = container_of(base, struct sample_fetch_kw_list, kw);
419 }
420
421 while (1) {
422
423 /* Check if kwl is the last entry. */
424 if (&kwl->list == &sample_fetches.list)
425 return NULL;
426
427 /* idx contain the next keyword. If it is available, return it. */
428 if (kwl->kw[*idx].kw) {
429 (*idx)++;
430 return &kwl->kw[(*idx)-1];
431 }
432
433 /* get next entry in the main list, and return NULL if the end is reached. */
434 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
435
436 /* Set index to 0, ans do one other loop. */
437 (*idx) = 0;
438 }
439}
440
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100441/* This function browses the list of available converters. <current> is
442 * the last used converter. If it is the first call, it must set to NULL.
443 * <idx> is the index of the next converter entry. It is used as private
444 * value. It is useless to initiate it.
445 *
446 * It returns always the next sample_conv entry, and NULL when the end of
447 * the list is reached.
448 */
449struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
450{
451 struct sample_conv_kw_list *kwl;
452 struct sample_conv *base;
453
454 if (!current) {
455 /* Get first kwl entry. */
456 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
457 (*idx) = 0;
458 } else {
459 /* Get kwl corresponding to the curret entry. */
460 base = current + 1 - (*idx);
461 kwl = container_of(base, struct sample_conv_kw_list, kw);
462 }
463
464 while (1) {
465 /* Check if kwl is the last entry. */
466 if (&kwl->list == &sample_convs.list)
467 return NULL;
468
469 /* idx contain the next keyword. If it is available, return it. */
470 if (kwl->kw[*idx].kw) {
471 (*idx)++;
472 return &kwl->kw[(*idx)-1];
473 }
474
475 /* get next entry in the main list, and return NULL if the end is reached. */
476 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
477
478 /* Set index to 0, ans do one other loop. */
479 (*idx) = 0;
480 }
481}
482
Emeric Brun107ca302010-01-04 16:16:05 +0100483/*
Willy Tarreau12785782012-04-27 21:37:17 +0200484 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100485 * string of <len> in buffer <kw>.
486 *
487 */
Willy Tarreau12785782012-04-27 21:37:17 +0200488struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100489{
490 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200491 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100492
Willy Tarreau12785782012-04-27 21:37:17 +0200493 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100494 for (index = 0; kwl->kw[index].kw != NULL; index++) {
495 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
496 kwl->kw[index].kw[len] == '\0')
497 return &kwl->kw[index];
498 }
499 }
500 return NULL;
501}
502
Emeric Brun107ca302010-01-04 16:16:05 +0100503/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200504/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100505/******************************************************************/
506
Willy Tarreau342acb42012-04-23 22:03:39 +0200507static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100508{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200509 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200510 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100511 return 1;
512}
513
Willy Tarreau342acb42012-04-23 22:03:39 +0200514static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100515{
Willy Tarreau83061a82018-07-13 11:56:34 +0200516 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100517
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200518 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100519 return 0;
520
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200521 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200522 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200523 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100524 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100525
526 return 1;
527}
528
Willy Tarreau342acb42012-04-23 22:03:39 +0200529static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100530{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200531 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200532 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100533 return 1;
534}
535
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200536static int c_ipv62ip(struct sample *smp)
537{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200538 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200539 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100540 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200541 return 1;
542}
543
Willy Tarreau342acb42012-04-23 22:03:39 +0200544static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100545{
Willy Tarreau83061a82018-07-13 11:56:34 +0200546 struct buffer *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100547
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200548 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100549 return 0;
550
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200551 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200552 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200553 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100554 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100555 return 1;
556}
557
558/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200559static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100560{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200561 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100562}
563*/
564
Willy Tarreau342acb42012-04-23 22:03:39 +0200565static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100566{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200567 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200568 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100569 return 1;
570}
571
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200572static int c_int2ipv6(struct sample *smp)
573{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200574 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
575 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200576 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200577 return 1;
578}
579
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100580static int c_str2addr(struct sample *smp)
581{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200582 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4)) {
583 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100584 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200585 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100586 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100587 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100588 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200589 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100590 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100591 return 1;
592}
593
Willy Tarreau342acb42012-04-23 22:03:39 +0200594static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100595{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200596 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100597 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200598 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100599 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100600 return 1;
601}
602
Willy Tarreau342acb42012-04-23 22:03:39 +0200603static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100604{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200605 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100606 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200607 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100608 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100609 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100610}
611
Emeric Brun4b9e8022014-11-03 18:17:10 +0100612/*
613 * The NULL char always enforces the end of string if it is met.
614 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100615 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200616static int c_bin2str(struct sample *smp)
617{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100618 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200619
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200620 for (i = 0; i < smp->data.u.str.data; i++) {
621 if (!smp->data.u.str.area[i]) {
622 smp->data.u.str.data = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100623 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100624 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200625 }
Christopher Faulet472ad512020-04-30 09:57:40 +0200626 smp->data.type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200627 return 1;
628}
629
Willy Tarreau342acb42012-04-23 22:03:39 +0200630static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100631{
Willy Tarreau83061a82018-07-13 11:56:34 +0200632 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100633 char *pos;
634
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200635 pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100636 if (!pos)
637 return 0;
638
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200639 trash->size = trash->size - (pos - trash->area);
640 trash->area = pos;
641 trash->data = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200642 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200643 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100644 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100645 return 1;
646}
647
Joseph Herlant757f5ad2018-11-15 12:14:56 -0800648/* This function unconditionally duplicates data and removes the "const" flag.
Willy Tarreauad635822016-08-08 19:21:09 +0200649 * For strings and binary blocks, it also provides a known allocated size with
650 * a length that is capped to the size, and ensures a trailing zero is always
651 * appended for strings. This is necessary for some operations which may
652 * require to extend the length. It returns 0 if it fails, 1 on success.
653 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100654int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200655{
Willy Tarreau83061a82018-07-13 11:56:34 +0200656 struct buffer *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200657
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200658 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100659 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100660 case SMP_T_SINT:
661 case SMP_T_ADDR:
662 case SMP_T_IPV4:
663 case SMP_T_IPV6:
664 /* These type are not const. */
665 break;
Willy Tarreauad635822016-08-08 19:21:09 +0200666
Christopher Fauletec100512017-07-24 15:38:41 +0200667 case SMP_T_METH:
668 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
669 break;
670 /* Fall through */
671
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100672 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200673 trash = get_trash_chunk();
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100674 trash->data = smp->data.type == SMP_T_STR ?
675 smp->data.u.str.data : smp->data.u.meth.str.data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200676 if (trash->data > trash->size - 1)
677 trash->data = trash->size - 1;
Willy Tarreauad635822016-08-08 19:21:09 +0200678
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100679 memcpy(trash->area, smp->data.type == SMP_T_STR ?
680 smp->data.u.str.area : smp->data.u.meth.str.area,
681 trash->data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200682 trash->area[trash->data] = 0;
Willy Tarreauad635822016-08-08 19:21:09 +0200683 smp->data.u.str = *trash;
684 break;
685
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100686 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100687 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200688 trash->data = smp->data.u.str.data;
689 if (trash->data > trash->size)
690 trash->data = trash->size;
Willy Tarreauad635822016-08-08 19:21:09 +0200691
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200692 memcpy(trash->area, smp->data.u.str.area, trash->data);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200693 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100694 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200695
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100696 default:
697 /* Other cases are unexpected. */
698 return 0;
699 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100700
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100701 /* remove const flag */
702 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200703 return 1;
704}
705
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100706int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100707{
708 return 1;
709}
710
Willy Tarreau342acb42012-04-23 22:03:39 +0200711static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100712{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200713 const char *str;
714 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100715
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200716 if (smp->data.u.str.data == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100717 return 0;
718
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200719 str = smp->data.u.str.area;
720 end = smp->data.u.str.area + smp->data.u.str.data;
Emeric Brun107ca302010-01-04 16:16:05 +0100721
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200722 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200723 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100724 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100725 return 1;
726}
727
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100728static int c_str2meth(struct sample *smp)
729{
730 enum http_meth_t meth;
731 int len;
732
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200733 meth = find_http_meth(smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100734 if (meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200735 len = smp->data.u.str.data;
736 smp->data.u.meth.str.area = smp->data.u.str.area;
737 smp->data.u.meth.str.data = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100738 }
739 else
740 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200741 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200742 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100743 return 1;
744}
745
746static int c_meth2str(struct sample *smp)
747{
748 int len;
749 enum http_meth_t meth;
750
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200751 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100752 /* The method is unknown. Copy the original pointer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200753 len = smp->data.u.meth.str.data;
754 smp->data.u.str.area = smp->data.u.meth.str.area;
755 smp->data.u.str.data = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200756 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100757 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200758 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100759 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200760 meth = smp->data.u.meth.meth;
Willy Tarreau35b51c62018-09-10 15:38:55 +0200761 smp->data.u.str.area = http_known_methods[meth].ptr;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200762 smp->data.u.str.data = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100763 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200764 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100765 }
766 else {
767 /* Unknown method */
768 return 0;
769 }
770 return 1;
771}
772
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200773static int c_addr2bin(struct sample *smp)
774{
Willy Tarreau83061a82018-07-13 11:56:34 +0200775 struct buffer *chk = get_trash_chunk();
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200776
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200777 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200778 chk->data = 4;
779 memcpy(chk->area, &smp->data.u.ipv4, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200780 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200781 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200782 chk->data = 16;
783 memcpy(chk->area, &smp->data.u.ipv6, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200784 }
785 else
786 return 0;
787
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200788 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200789 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200790 return 1;
791}
792
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200793static int c_int2bin(struct sample *smp)
794{
Willy Tarreau83061a82018-07-13 11:56:34 +0200795 struct buffer *chk = get_trash_chunk();
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200796
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200797 *(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
798 chk->data = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200799
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200800 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200801 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200802 return 1;
803}
804
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200805
Emeric Brun107ca302010-01-04 16:16:05 +0100806/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200807/* Sample casts matrix: */
808/* sample_casts[from type][to type] */
809/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100810/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100811
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100812sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200813/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
814/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
815/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200816/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, c_int2ipv6, c_int2str, c_int2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200817/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
818/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200819/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200820/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
821/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
822/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200823};
Emeric Brun107ca302010-01-04 16:16:05 +0100824
Emeric Brun107ca302010-01-04 16:16:05 +0100825/*
Willy Tarreau12785782012-04-27 21:37:17 +0200826 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100827 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200828 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200829 * The caller must have set al->ctx.
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100830 * If <endptr> is non-nul, it will be set to the first unparsed character
831 * (which may be the final '\0') on success. If it is nul, the expression
832 * must be properly terminated by a '\0' otherwise an error is reported.
Emeric Brun107ca302010-01-04 16:16:05 +0100833 */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100834struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err_msg, struct arg_list *al, char **endptr)
Emeric Brun107ca302010-01-04 16:16:05 +0100835{
Willy Tarreau833cc792013-07-24 15:34:19 +0200836 const char *begw; /* beginning of word */
837 const char *endw; /* end of word */
838 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200839 struct sample_expr *expr;
840 struct sample_fetch *fetch;
841 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100842 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200843 char *fkw = NULL;
844 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100845 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100846
Willy Tarreau833cc792013-07-24 15:34:19 +0200847 begw = str[*idx];
Willy Tarreaued2c6622020-02-14 18:27:10 +0100848 for (endw = begw; is_idchar(*endw); endw++)
849 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200850
851 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100852 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100853 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200854 }
Emeric Brun107ca302010-01-04 16:16:05 +0100855
Willy Tarreau833cc792013-07-24 15:34:19 +0200856 /* keep a copy of the current fetch keyword for error reporting */
857 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100858
Willy Tarreau833cc792013-07-24 15:34:19 +0200859 fetch = find_sample_fetch(begw, endw - begw);
860 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100861 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100862 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200863 }
Emeric Brun107ca302010-01-04 16:16:05 +0100864
Willy Tarreau833cc792013-07-24 15:34:19 +0200865 /* At this point, we have :
866 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100867 * - endw : end of the keyword, first character not part of keyword
Willy Tarreau833cc792013-07-24 15:34:19 +0200868 */
869
870 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100871 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100872 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200873 }
Emeric Brun107ca302010-01-04 16:16:05 +0100874 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200875
Vincent Bernat02779b62016-04-03 13:48:43 +0200876 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200877 if (!expr)
878 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100879
880 LIST_INIT(&(expr->conv_exprs));
881 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200882 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100883
Willy Tarreau689a1df2013-12-13 00:40:11 +0100884 /* Note that we call the argument parser even with an empty string,
885 * this allows it to automatically create entries for mandatory
886 * implicit arguments (eg: local proxy name).
887 */
888 al->kw = expr->fetch->kw;
889 al->conv = NULL;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100890 if (make_arg_list(endw, -1, fetch->arg_mask, &expr->arg_p, err_msg, &endt, &err_arg, al) < 0) {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100891 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
892 goto out_error;
893 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200894
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100895 /* now endt is our first char not part of the arg list, typically the
896 * comma after the sample fetch name or after the closing parenthesis,
897 * or the NUL char.
898 */
899
Willy Tarreau689a1df2013-12-13 00:40:11 +0100900 if (!expr->arg_p) {
901 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200902 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100903 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
904 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200905 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100906 }
907
Willy Tarreau833cc792013-07-24 15:34:19 +0200908 /* Now process the converters if any. We have two supported syntaxes
909 * for the converters, which can be combined :
910 * - comma-delimited list of converters just after the keyword and args ;
911 * - one converter per keyword
912 * The combination allows to have each keyword being a comma-delimited
913 * series of converters.
914 *
915 * We want to process the former first, then the latter. For this we start
916 * from the beginning of the supposed place in the exiting conv chain, which
917 * starts at the last comma (endt).
918 */
919
920 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200921 struct sample_conv_expr *conv_expr;
Willy Tarreau46dfd782019-12-17 10:25:29 +0100922 int err_arg;
923 int argcnt;
Emeric Brun107ca302010-01-04 16:16:05 +0100924
Willy Tarreau833cc792013-07-24 15:34:19 +0200925 if (*endt && *endt != ',') {
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100926 if (endptr) {
927 /* end found, let's stop here */
928 break;
929 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200930 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100931 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200932 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100933 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100934 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200935 }
Emeric Brun107ca302010-01-04 16:16:05 +0100936
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100937 /* FIXME: how long should we support such idiocies ? Maybe we
938 * should already warn ?
939 */
Willy Tarreau833cc792013-07-24 15:34:19 +0200940 while (*endt == ',') /* then trailing commas */
941 endt++;
942
Willy Tarreau97108e02016-11-25 07:33:24 +0100943 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200944
945 if (!*begw) {
946 /* none ? skip to next string */
947 (*idx)++;
948 begw = str[*idx];
949 if (!begw || !*begw)
950 break;
951 }
952
Willy Tarreaued2c6622020-02-14 18:27:10 +0100953 for (endw = begw; is_idchar(*endw); endw++)
954 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200955
956 free(ckw);
957 ckw = my_strndup(begw, endw - begw);
958
959 conv = find_sample_conv(begw, endw - begw);
960 if (!conv) {
961 /* we found an isolated keyword that we don't know, it's not ours */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100962 if (begw == str[*idx]) {
963 endt = begw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200964 break;
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100965 }
Willy Tarreau97108e02016-11-25 07:33:24 +0100966 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200967 goto out_error;
968 }
Emeric Brun107ca302010-01-04 16:16:05 +0100969
Willy Tarreau833cc792013-07-24 15:34:19 +0200970 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100971 memprintf(err_msg, "returns type of converter '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100972 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200973 }
Emeric Brun107ca302010-01-04 16:16:05 +0100974
975 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200976 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100977 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100978 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200979 }
Emeric Brun107ca302010-01-04 16:16:05 +0100980
981 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +0200982 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200983 if (!conv_expr)
984 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100985
986 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
987 conv_expr->conv = conv;
988
Willy Tarreau46dfd782019-12-17 10:25:29 +0100989 al->kw = expr->fetch->kw;
990 al->conv = conv_expr->conv->kw;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100991 argcnt = make_arg_list(endw, -1, conv->arg_mask, &conv_expr->arg_p, err_msg, &endt, &err_arg, al);
Willy Tarreau46dfd782019-12-17 10:25:29 +0100992 if (argcnt < 0) {
993 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
994 goto out_error;
995 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100996
Willy Tarreau46dfd782019-12-17 10:25:29 +0100997 if (argcnt && !conv->arg_mask) {
998 memprintf(err_msg, "converter '%s' does not support any args", ckw);
999 goto out_error;
1000 }
Willy Tarreau21d68a62012-04-20 15:52:36 +02001001
Willy Tarreau46dfd782019-12-17 10:25:29 +01001002 if (!conv_expr->arg_p)
1003 conv_expr->arg_p = empty_arg_list;
Willy Tarreau2e845be2012-10-19 19:49:09 +02001004
Willy Tarreau46dfd782019-12-17 10:25:29 +01001005 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
1006 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001007 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001008 }
1009 }
Emeric Brun485479d2010-09-23 18:02:19 +02001010
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001011 if (endptr) {
1012 /* end found, let's stop here */
1013 *endptr = (char *)endt;
1014 }
1015
Willy Tarreau833cc792013-07-24 15:34:19 +02001016 out:
1017 free(fkw);
1018 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001019 return expr;
1020
1021out_error:
Willy Tarreau12785782012-04-27 21:37:17 +02001022 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +02001023 expr = NULL;
1024 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001025}
1026
1027/*
Willy Tarreau12785782012-04-27 21:37:17 +02001028 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001029 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001030 * Returns a pointer on a typed sample structure containing the result or NULL if
1031 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001032 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001033 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001034 *
1035 * Note: the fetch functions are required to properly set the return type. The
1036 * conversion functions must do so too. However the cast functions do not need
1037 * to since they're made to cast mutiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001038 *
1039 * The caller may indicate in <opt> if it considers the result final or not.
1040 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1041 * if the result is stable or not, according to the following table :
1042 *
1043 * return MAY_CHANGE FINAL Meaning for the sample
1044 * NULL 0 * Not present and will never be (eg: header)
1045 * NULL 1 0 Not present yet, could change (eg: POST param)
1046 * NULL 1 1 Not present yet, will not change anymore
1047 * smp 0 * Present and will not change (eg: header)
1048 * smp 1 0 Present, may change (eg: request length)
1049 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001050 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001051struct sample *sample_process(struct proxy *px, struct session *sess,
1052 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001053 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001054{
Willy Tarreau12785782012-04-27 21:37:17 +02001055 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001056
Willy Tarreau18387e22013-07-25 12:02:38 +02001057 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001058 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001059 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001060 }
Emeric Brun107ca302010-01-04 16:16:05 +01001061
Willy Tarreau1777ea62016-03-10 16:15:46 +01001062 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001063 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001064 return NULL;
1065
Emeric Brun107ca302010-01-04 16:16:05 +01001066 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001067 /* we want to ensure that p->type can be casted into
1068 * conv_expr->conv->in_type. We have 3 possibilities :
1069 * - NULL => not castable.
1070 * - c_none => nothing to do (let's optimize it)
1071 * - other => apply cast and prepare to fail
1072 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001073 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001074 return NULL;
1075
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001076 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1077 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001078 return NULL;
1079
Willy Tarreau12e50112012-04-25 17:21:49 +02001080 /* OK cast succeeded */
1081
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001082 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001083 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001084 }
1085 return p;
1086}
1087
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001088/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001089 * Resolve all remaining arguments in proxy <p>. Returns the number of
1090 * errors or 0 if everything is fine.
1091 */
1092int smp_resolve_args(struct proxy *p)
1093{
1094 struct arg_list *cur, *bak;
1095 const char *ctx, *where;
1096 const char *conv_ctx, *conv_pre, *conv_pos;
1097 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001098 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001099 struct arg *arg;
1100 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001101 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001102
1103 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1104 struct proxy *px;
1105 struct server *srv;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001106 struct stktable *t;
1107 char *pname, *sname, *stktname;
Willy Tarreau46947782015-01-19 19:00:58 +01001108 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001109
1110 arg = cur->arg;
1111
1112 /* prepare output messages */
1113 conv_pre = conv_pos = conv_ctx = "";
1114 if (cur->conv) {
1115 conv_ctx = cur->conv;
1116 conv_pre = "conversion keyword '";
1117 conv_pos = "' for ";
1118 }
1119
1120 where = "in";
1121 ctx = "sample fetch keyword";
1122 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001123 case ARGC_STK: where = "in stick rule in"; break;
1124 case ARGC_TRK: where = "in tracking rule in"; break;
1125 case ARGC_LOG: where = "in log-format string in"; break;
1126 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1127 case ARGC_HRQ: where = "in http-request header format string in"; break;
1128 case ARGC_HRS: where = "in http-response header format string in"; break;
1129 case ARGC_UIF: where = "in unique-id-format string in"; break;
1130 case ARGC_RDR: where = "in redirect format string in"; break;
1131 case ARGC_CAP: where = "in capture rule in"; break;
1132 case ARGC_ACL: ctx = "ACL keyword"; break;
1133 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001134 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Christopher Faulet3b967c12020-05-15 15:47:44 +02001135 case ARGC_HERR: where = "in http-error directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001136 }
1137
1138 /* set a few default settings */
1139 px = p;
1140 pname = p->id;
1141
1142 switch (arg->type) {
1143 case ARGT_SRV:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001144 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001145 ha_alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1146 cur->file, cur->line,
1147 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001148 cfgerr++;
1149 continue;
1150 }
1151
1152 /* we support two formats : "bck/srv" and "srv" */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001153 sname = strrchr(arg->data.str.area, '/');
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001154
1155 if (sname) {
1156 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001157 pname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001158
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001159 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001160 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001161 ha_alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1162 cur->file, cur->line, pname,
1163 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001164 cfgerr++;
1165 break;
1166 }
1167 }
1168 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001169 sname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001170
1171 srv = findserver(px, sname);
1172 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001173 ha_alert("parsing [%s:%d] : unable to find server '%s' in proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1174 cur->file, cur->line, sname, pname,
1175 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001176 cfgerr++;
1177 break;
1178 }
1179
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001180 free(arg->data.str.area);
1181 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001182 arg->unresolved = 0;
1183 arg->data.srv = srv;
1184 break;
1185
1186 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001187 if (arg->data.str.data) {
1188 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001189 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001190 }
1191
1192 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001193 ha_alert("parsing [%s:%d] : unable to find frontend '%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);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001196 cfgerr++;
1197 break;
1198 }
1199
1200 if (!(px->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001201 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1202 cur->file, cur->line, pname,
1203 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001204 cfgerr++;
1205 break;
1206 }
1207
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001208 free(arg->data.str.area);
1209 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001210 arg->unresolved = 0;
1211 arg->data.prx = px;
1212 break;
1213
1214 case ARGT_BE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001215 if (arg->data.str.data) {
1216 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001217 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001218 }
1219
1220 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001221 ha_alert("parsing [%s:%d] : unable to find backend '%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);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001224 cfgerr++;
1225 break;
1226 }
1227
1228 if (!(px->cap & PR_CAP_BE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001229 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1230 cur->file, cur->line, pname,
1231 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001232 cfgerr++;
1233 break;
1234 }
1235
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001236 free(arg->data.str.area);
1237 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001238 arg->unresolved = 0;
1239 arg->data.prx = px;
1240 break;
1241
1242 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001243 if (arg->data.str.data)
1244 stktname = arg->data.str.area;
1245 else
1246 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001247
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001248 t = stktable_find_by_name(stktname);
1249 if (!t) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001250 ha_alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001251 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001252 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001253 cfgerr++;
1254 break;
1255 }
1256
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001257 if (!t->size) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001258 ha_alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001259 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001260 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001261 cfgerr++;
1262 break;
1263 }
1264
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001265 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001266 ha_alert("parsing [%s:%d] : stick-table '%s' not present on all processes covered by proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001267 cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001268 cfgerr++;
1269 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001270 }
1271
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001272 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001273 p->next_stkt_ref = t->proxies_list;
1274 t->proxies_list = p;
1275 }
1276
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001277 free(arg->data.str.area);
1278 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001279 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001280 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001281 break;
1282
1283 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001284 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001285 ha_alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1286 cur->file, cur->line,
1287 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001288 cfgerr++;
1289 break;
1290 }
1291
1292 if (p->uri_auth && p->uri_auth->userlist &&
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001293 !strcmp(p->uri_auth->userlist->name, arg->data.str.area))
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001294 ul = p->uri_auth->userlist;
1295 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001296 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001297
1298 if (!ul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001299 ha_alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001300 cur->file, cur->line,
1301 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001302 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001303 cfgerr++;
1304 break;
1305 }
1306
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001307 free(arg->data.str.area);
1308 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001309 arg->unresolved = 0;
1310 arg->data.usr = ul;
1311 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001312
1313 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001314 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001315 ha_alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1316 cur->file, cur->line,
1317 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001318 cfgerr++;
1319 continue;
1320 }
1321
Willy Tarreau46947782015-01-19 19:00:58 +01001322 rflags = 0;
1323 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1324 err = NULL;
1325
Dragan Dosen26743032019-04-30 15:54:36 +02001326 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001327 ha_alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1328 cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001329 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001330 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
Willy Tarreau46947782015-01-19 19:00:58 +01001331 cfgerr++;
1332 continue;
1333 }
1334
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001335 free(arg->data.str.area);
1336 arg->data.str.area = NULL;
Willy Tarreau46947782015-01-19 19:00:58 +01001337 arg->unresolved = 0;
1338 arg->data.reg = reg;
1339 break;
1340
1341
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001342 }
1343
1344 LIST_DEL(&cur->list);
1345 free(cur);
1346 } /* end of args processing */
1347
1348 return cfgerr;
1349}
1350
1351/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001352 * Process a fetch + format conversion as defined by the sample expression
1353 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001354 * not explicitly set to <smp_type>, but shall be compatible with it as
1355 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1356 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001357 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1358 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1359 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1360 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001361 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1362 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1363 * still hope to get it after waiting longer, and is not converted to string.
1364 * The possible output combinations are the following :
1365 *
1366 * return MAY_CHANGE FINAL Meaning for the sample
1367 * NULL * * Not present and will never be (eg: header)
1368 * smp 0 * Final value converted (eg: header)
1369 * smp 1 0 Not present yet, may appear later (eg: header)
1370 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001371 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001372struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001373 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001374 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001375{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001376 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001377
Willy Tarreau6c616e02014-06-25 16:56:41 +02001378 memset(smp, 0, sizeof(*smp));
1379
Willy Tarreau192252e2015-04-04 01:47:55 +02001380 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001381 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1382 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001383 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001384 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001385
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001386 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001387 return NULL;
1388
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001389 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001390 return NULL;
1391
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001392 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001393 return smp;
1394}
1395
Christopher Faulet476e5d02016-10-26 11:34:47 +02001396static void release_sample_arg(struct arg *p)
1397{
1398 struct arg *p_back = p;
1399
1400 if (!p)
1401 return;
1402
1403 while (p->type != ARGT_STOP) {
1404 if (p->type == ARGT_STR || p->unresolved) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001405 free(p->data.str.area);
1406 p->data.str.area = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001407 p->unresolved = 0;
1408 }
1409 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001410 regex_free(p->data.reg);
1411 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001412 }
1413 p++;
1414 }
1415
1416 if (p_back != empty_arg_list)
1417 free(p_back);
1418}
1419
1420void release_sample_expr(struct sample_expr *expr)
1421{
1422 struct sample_conv_expr *conv_expr, *conv_exprb;
1423
1424 if (!expr)
1425 return;
1426
1427 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list)
1428 release_sample_arg(conv_expr->arg_p);
1429 release_sample_arg(expr->arg_p);
1430 free(expr);
1431}
1432
Emeric Brun107ca302010-01-04 16:16:05 +01001433/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001434/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001435/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001436/*****************************************************************/
1437
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001438static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1439{
1440 int i;
1441 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001442 struct buffer *buf;
1443 struct sink *sink;
1444 struct ist line;
1445 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001446
Willy Tarreau0851fd52019-12-17 10:07:25 +01001447 buf = alloc_trash_chunk();
1448 if (!buf)
1449 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001450
Willy Tarreau0851fd52019-12-17 10:07:25 +01001451 sink = (struct sink *)arg_p[1].data.str.area;
1452 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001453
Willy Tarreau0851fd52019-12-17 10:07:25 +01001454 pfx = arg_p[0].data.str.area;
1455 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001456
Willy Tarreau0851fd52019-12-17 10:07:25 +01001457 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1458 if (!sample_casts[smp->data.type][SMP_T_STR])
1459 goto nocast;
1460
1461 /* Copy sample fetch. This puts the sample as const, the
1462 * cast will copy data if a transformation is required.
1463 */
1464 memcpy(&tmp, smp, sizeof(struct sample));
1465 tmp.flags = SMP_F_CONST;
1466
1467 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1468 goto nocast;
1469
1470 /* Display the displayable chars*. */
1471 b_putchr(buf, '<');
1472 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001473 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001474 b_putchr(buf, tmp.data.u.str.area[i]);
1475 else
1476 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001477 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001478 b_putchr(buf, '>');
1479
1480 done:
1481 line = ist2(buf->area, buf->data);
Emeric Brunbd163812020-05-06 14:33:46 +02001482 sink_write(sink, &line, 1, 0, 0, NULL, NULL, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001483 end:
1484 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001485 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001486 nocast:
1487 chunk_appendf(buf, "(undisplayable)");
1488 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001489}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001490
1491// This function checks the "debug" converter's arguments.
1492static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1493 const char *file, int line, char **err)
1494{
1495 const char *name = "buf0";
1496 struct sink *sink = NULL;
1497
1498 if (args[0].type != ARGT_STR) {
1499 /* optional prefix */
1500 args[0].data.str.area = "";
1501 args[0].data.str.data = 0;
1502 }
1503
1504 if (args[1].type == ARGT_STR)
1505 name = args[1].data.str.area;
1506
1507 sink = sink_find(name);
1508 if (!sink) {
1509 memprintf(err, "No such sink '%s'", name);
1510 return 0;
1511 }
1512
1513 args[1].data.str.area = (char *)sink;
1514 args[1].data.str.data = 0; // that's not a string anymore
1515 return 1;
1516}
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001517
Holger Just1bfc24b2017-05-06 00:56:53 +02001518static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1519{
Willy Tarreau83061a82018-07-13 11:56:34 +02001520 struct buffer *trash = get_trash_chunk();
Holger Just1bfc24b2017-05-06 00:56:53 +02001521 int bin_len;
1522
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001523 trash->data = 0;
1524 bin_len = base64dec(smp->data.u.str.area, smp->data.u.str.data,
1525 trash->area, trash->size);
Holger Just1bfc24b2017-05-06 00:56:53 +02001526 if (bin_len < 0)
1527 return 0;
1528
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001529 trash->data = bin_len;
Holger Just1bfc24b2017-05-06 00:56:53 +02001530 smp->data.u.str = *trash;
1531 smp->data.type = SMP_T_BIN;
1532 smp->flags &= ~SMP_F_CONST;
1533 return 1;
1534}
1535
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001536static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001537{
Willy Tarreau83061a82018-07-13 11:56:34 +02001538 struct buffer *trash = get_trash_chunk();
Emeric Brun53d1a982014-04-30 18:21:37 +02001539 int b64_len;
1540
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001541 trash->data = 0;
1542 b64_len = a2base64(smp->data.u.str.area, smp->data.u.str.data,
1543 trash->area, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001544 if (b64_len < 0)
1545 return 0;
1546
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001547 trash->data = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001548 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001549 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001550 smp->flags &= ~SMP_F_CONST;
1551 return 1;
1552}
1553
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001554static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1555{
1556 blk_SHA_CTX ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001557 struct buffer *trash = get_trash_chunk();
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001558
1559 memset(&ctx, 0, sizeof(ctx));
1560
1561 blk_SHA1_Init(&ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001562 blk_SHA1_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1563 blk_SHA1_Final((unsigned char *) trash->area, &ctx);
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001564
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001565 trash->data = 20;
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001566 smp->data.u.str = *trash;
1567 smp->data.type = SMP_T_BIN;
1568 smp->flags &= ~SMP_F_CONST;
1569 return 1;
1570}
1571
Tim Duesterhusd4376302019-06-17 12:41:44 +02001572#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01001573static int smp_check_sha2(struct arg *args, struct sample_conv *conv,
1574 const char *file, int line, char **err)
1575{
1576 if (args[0].type == ARGT_STOP)
1577 return 1;
1578 if (args[0].type != ARGT_SINT) {
1579 memprintf(err, "Invalid type '%s'", arg_type_names[args[0].type]);
1580 return 0;
1581 }
1582
1583 switch (args[0].data.sint) {
1584 case 224:
1585 case 256:
1586 case 384:
1587 case 512:
1588 /* this is okay */
1589 return 1;
1590 default:
1591 memprintf(err, "Unsupported number of bits: '%lld'", args[0].data.sint);
1592 return 0;
1593 }
1594}
1595
Tim Duesterhusd4376302019-06-17 12:41:44 +02001596static int sample_conv_sha2(const struct arg *arg_p, struct sample *smp, void *private)
1597{
1598 struct buffer *trash = get_trash_chunk();
1599 int bits = 256;
1600 if (arg_p && arg_p->data.sint)
1601 bits = arg_p->data.sint;
1602
1603 switch (bits) {
1604 case 224: {
1605 SHA256_CTX ctx;
1606
1607 memset(&ctx, 0, sizeof(ctx));
1608
1609 SHA224_Init(&ctx);
1610 SHA224_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1611 SHA224_Final((unsigned char *) trash->area, &ctx);
1612 trash->data = SHA224_DIGEST_LENGTH;
1613 break;
1614 }
1615 case 256: {
1616 SHA256_CTX ctx;
1617
1618 memset(&ctx, 0, sizeof(ctx));
1619
1620 SHA256_Init(&ctx);
1621 SHA256_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1622 SHA256_Final((unsigned char *) trash->area, &ctx);
1623 trash->data = SHA256_DIGEST_LENGTH;
1624 break;
1625 }
1626 case 384: {
1627 SHA512_CTX ctx;
1628
1629 memset(&ctx, 0, sizeof(ctx));
1630
1631 SHA384_Init(&ctx);
1632 SHA384_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1633 SHA384_Final((unsigned char *) trash->area, &ctx);
1634 trash->data = SHA384_DIGEST_LENGTH;
1635 break;
1636 }
1637 case 512: {
1638 SHA512_CTX ctx;
1639
1640 memset(&ctx, 0, sizeof(ctx));
1641
1642 SHA512_Init(&ctx);
1643 SHA512_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1644 SHA512_Final((unsigned char *) trash->area, &ctx);
1645 trash->data = SHA512_DIGEST_LENGTH;
1646 break;
1647 }
1648 default:
1649 return 0;
1650 }
1651
1652 smp->data.u.str = *trash;
1653 smp->data.type = SMP_T_BIN;
1654 smp->flags &= ~SMP_F_CONST;
1655 return 1;
1656}
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001657
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001658static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
1659{
1660 switch (arg->type) {
1661 case ARGT_STR:
1662 smp->data.type = SMP_T_STR;
1663 smp->data.u.str = arg->data.str;
1664 return 1;
1665 case ARGT_VAR:
1666 if (!vars_get_by_desc(&arg->data.var, smp))
1667 return 0;
1668 if (!sample_casts[smp->data.type][SMP_T_STR])
1669 return 0;
1670 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
1671 return 0;
1672 return 1;
1673 default:
1674 return 0;
1675 }
1676}
1677
Patrick Gansterer8e366512020-04-22 16:47:57 +02001678#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001679static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
1680 const char *file, int line, char **err)
1681{
1682 switch(args[0].data.sint) {
1683 case 128:
1684 case 192:
1685 case 256:
1686 break;
1687 default:
1688 memprintf(err, "key size must be 128, 192 or 256 (bits).");
1689 return 0;
1690 }
1691 /* Try to decode a variable. */
1692 vars_check_arg(&args[1], NULL);
1693 vars_check_arg(&args[2], NULL);
1694 vars_check_arg(&args[3], NULL);
1695 return 1;
1696}
1697
1698/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
1699static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
1700{
1701 struct sample nonce, key, aead_tag;
1702 struct buffer *smp_trash, *smp_trash_alloc;
1703 EVP_CIPHER_CTX *ctx;
1704 int dec_size, ret;
1705
1706 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
1707 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
1708 return 0;
1709
1710 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1711 if (!sample_conv_var2smp_str(&arg_p[2], &key))
1712 return 0;
1713
1714 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
1715 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
1716 return 0;
1717
1718 smp_trash = get_trash_chunk();
1719 smp_trash_alloc = alloc_trash_chunk();
1720 if (!smp_trash_alloc)
1721 return 0;
1722
1723 ctx = EVP_CIPHER_CTX_new();
1724
1725 if (!ctx)
1726 goto err;
1727
1728 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
1729 if (dec_size < 0)
1730 goto err;
1731 smp_trash->data = dec_size;
1732
1733 /* Set cipher type and mode */
1734 switch(arg_p[0].data.sint) {
1735 case 128:
1736 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
1737 break;
1738 case 192:
1739 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
1740 break;
1741 case 256:
1742 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
1743 break;
1744 }
1745
1746 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, smp_trash->data, NULL);
1747
1748 /* Initialise IV */
1749 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) smp_trash->area))
1750 goto err;
1751
1752 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
1753 if (dec_size < 0)
1754 goto err;
1755 smp_trash->data = dec_size;
1756
1757 /* Initialise key */
1758 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) smp_trash->area, NULL))
1759 goto err;
1760
1761 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
1762 (unsigned char *) smp->data.u.str.area, (int) smp->data.u.str.data))
1763 goto err;
1764
1765 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
1766 if (dec_size < 0)
1767 goto err;
1768 smp_trash_alloc->data = dec_size;
1769 dec_size = smp_trash->data;
1770
1771 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, smp_trash_alloc->data, (void *) smp_trash_alloc->area);
1772 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
1773
1774 if (ret <= 0)
1775 goto err;
1776
1777 smp->data.u.str.data = dec_size + smp_trash->data;
1778 smp->data.u.str.area = smp_trash->area;
1779 smp->data.type = SMP_T_BIN;
1780 smp->flags &= ~SMP_F_CONST;
1781 free_trash_chunk(smp_trash_alloc);
1782 return 1;
1783
1784err:
1785 free_trash_chunk(smp_trash_alloc);
1786 return 0;
1787}
1788#endif /* HA_OPENSSL_VERSION_NUMBER */
1789
Patrick Gansterer8e366512020-04-22 16:47:57 +02001790static int check_crypto_digest(struct arg *args, struct sample_conv *conv,
1791 const char *file, int line, char **err)
1792{
1793 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1794
1795 if (evp)
1796 return 1;
1797
1798 memprintf(err, "algorithm must be a valid OpenSSL message digest name.");
1799 return 0;
1800}
1801
1802static int sample_conv_crypto_digest(const struct arg *args, struct sample *smp, void *private)
1803{
1804 struct buffer *trash = get_trash_chunk();
1805 unsigned char *md = (unsigned char*) trash->area;
1806 unsigned int md_len = trash->size;
1807 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
1808 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1809
1810 if (!ctx)
1811 return 0;
1812
1813 if (!EVP_DigestInit_ex(ctx, evp, NULL) ||
1814 !EVP_DigestUpdate(ctx, smp->data.u.str.area, smp->data.u.str.data) ||
1815 !EVP_DigestFinal_ex(ctx, md, &md_len)) {
1816 EVP_MD_CTX_free(ctx);
1817 return 0;
1818 }
1819
1820 EVP_MD_CTX_free(ctx);
1821
1822 trash->data = md_len;
1823 smp->data.u.str = *trash;
1824 smp->data.type = SMP_T_BIN;
1825 smp->flags &= ~SMP_F_CONST;
1826 return 1;
1827}
1828
1829static int check_crypto_hmac(struct arg *args, struct sample_conv *conv,
1830 const char *file, int line, char **err)
1831{
1832 if (!check_crypto_digest(args, conv, file, line, err))
1833 return 0;
1834
1835 vars_check_arg(&args[1], NULL);
1836 return 1;
1837}
1838
1839static int sample_conv_crypto_hmac(const struct arg *args, struct sample *smp, void *private)
1840{
1841 struct sample key;
1842 struct buffer *trash, *key_trash;
1843 unsigned char *md;
1844 unsigned int md_len;
1845 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1846 int dec_size;
1847
1848 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1849 if (!sample_conv_var2smp_str(&args[1], &key))
1850 return 0;
1851
1852 trash = get_trash_chunk();
1853 key_trash = alloc_trash_chunk();
1854 if (!key_trash)
1855 return 0;
1856
1857 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, key_trash->area, key_trash->size);
1858 if (dec_size < 0)
1859 goto err;
1860
1861 md = (unsigned char*) trash->area;
1862 md_len = trash->size;
1863 if (!HMAC(evp, key_trash->area, dec_size, (const unsigned char*) smp->data.u.str.area, smp->data.u.str.data, md, &md_len))
1864 goto err;
1865
1866 free_trash_chunk(key_trash);
1867
1868 trash->data = md_len;
1869 smp->data.u.str = *trash;
1870 smp->data.type = SMP_T_BIN;
1871 smp->flags &= ~SMP_F_CONST;
1872 return 1;
1873
1874err:
1875 free_trash_chunk(key_trash);
1876 return 0;
1877}
1878
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001879#endif /* USE_OPENSSL */
Tim Duesterhusd4376302019-06-17 12:41:44 +02001880
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001881static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001882{
Willy Tarreau83061a82018-07-13 11:56:34 +02001883 struct buffer *trash = get_trash_chunk();
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001884 unsigned char c;
1885 int ptr = 0;
1886
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001887 trash->data = 0;
1888 while (ptr < smp->data.u.str.data && trash->data <= trash->size - 2) {
1889 c = smp->data.u.str.area[ptr++];
1890 trash->area[trash->data++] = hextab[(c >> 4) & 0xF];
1891 trash->area[trash->data++] = hextab[c & 0xF];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001892 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001893 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001894 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001895 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001896 return 1;
1897}
1898
Dragan Dosen3f957b22017-10-24 09:27:34 +02001899static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
1900{
1901 long long int n = 0;
1902 int i, c;
1903
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001904 for (i = 0; i < smp->data.u.str.data; i++) {
1905 if ((c = hex2i(smp->data.u.str.area[i])) < 0)
Dragan Dosen3f957b22017-10-24 09:27:34 +02001906 return 0;
1907 n = (n << 4) + c;
1908 }
1909
1910 smp->data.u.sint = n;
1911 smp->data.type = SMP_T_SINT;
1912 smp->flags &= ~SMP_F_CONST;
1913 return 1;
1914}
1915
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001916/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001917static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001918{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001919 smp->data.u.sint = hash_djb2(smp->data.u.str.area,
1920 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001921 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001922 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001923 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001924 return 1;
1925}
1926
Willy Tarreau60a2ee72017-12-15 07:13:48 +01001927static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001928{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001929 int i = smp->data.u.str.data;
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001930 smp->data.u.sint = i;
1931 smp->data.type = SMP_T_SINT;
1932 return 1;
1933}
1934
1935
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001936static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001937{
1938 int i;
1939
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001940 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001941 return 0;
1942
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001943 for (i = 0; i < smp->data.u.str.data; i++) {
1944 if ((smp->data.u.str.area[i] >= 'A') && (smp->data.u.str.area[i] <= 'Z'))
1945 smp->data.u.str.area[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001946 }
1947 return 1;
1948}
1949
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001950static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001951{
1952 int i;
1953
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001954 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02001955 return 0;
1956
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001957 for (i = 0; i < smp->data.u.str.data; i++) {
1958 if ((smp->data.u.str.area[i] >= 'a') && (smp->data.u.str.area[i] <= 'z'))
1959 smp->data.u.str.area[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001960 }
1961 return 1;
1962}
1963
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001964/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
1965static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001966{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001967 /* Attempt to convert to IPv4 to apply the correct mask. */
1968 c_ipv62ip(smp);
1969
1970 if (smp->data.type == SMP_T_IPV4) {
1971 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
1972 smp->data.type = SMP_T_IPV4;
1973 }
1974 else if (smp->data.type == SMP_T_IPV6) {
1975 /* IPv6 cannot be converted without an IPv6 mask. */
1976 if (args[1].type != ARGT_IPV6)
1977 return 0;
1978
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +01001979 write_u64(&smp->data.u.ipv6.s6_addr[0],
1980 read_u64(&smp->data.u.ipv6.s6_addr[0]) & read_u64(&args[1].data.ipv6.s6_addr[0]));
1981 write_u64(&smp->data.u.ipv6.s6_addr[8],
1982 read_u64(&smp->data.u.ipv6.s6_addr[8]) & read_u64(&args[1].data.ipv6.s6_addr[8]));
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001983 smp->data.type = SMP_T_IPV6;
1984 }
1985
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001986 return 1;
1987}
1988
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001989/* takes an UINT value on input supposed to represent the time since EPOCH,
1990 * adds an optional offset found in args[1] and emits a string representing
1991 * the local time in the format specified in args[1] using strftime().
1992 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001993static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001994{
Willy Tarreau83061a82018-07-13 11:56:34 +02001995 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001996 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001997 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001998 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001999
2000 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002001 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002002 curr_date += args[1].data.sint;
2003
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002004 tm = localtime(&curr_date);
2005 if (!tm)
2006 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002007 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002008 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2009 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002010 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002011 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002012 return 1;
2013}
2014
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002015/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002016static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002017{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002018 smp->data.u.sint = hash_sdbm(smp->data.u.str.area,
2019 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002020 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002021 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002022 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002023 return 1;
2024}
2025
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002026/* takes an UINT value on input supposed to represent the time since EPOCH,
2027 * adds an optional offset found in args[1] and emits a string representing
2028 * the UTC date in the format specified in args[1] using strftime().
2029 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002030static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002031{
Willy Tarreau83061a82018-07-13 11:56:34 +02002032 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002033 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002034 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002035 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002036
2037 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002038 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002039 curr_date += args[1].data.sint;
2040
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002041 tm = gmtime(&curr_date);
2042 if (!tm)
2043 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002044 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002045 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2046 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002047 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002048 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002049 return 1;
2050}
2051
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002052/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002053static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002054{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002055 smp->data.u.sint = hash_wt6(smp->data.u.str.area,
2056 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002057 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002058 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002059 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002060 return 1;
2061}
2062
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002063/* hashes the binary input into a 32-bit unsigned int using xxh.
2064 * The seed of the hash defaults to 0 but can be changd in argument 1.
2065 */
2066static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
2067{
2068 unsigned int seed;
2069
2070 if (arg_p && arg_p->data.sint)
2071 seed = arg_p->data.sint;
2072 else
2073 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002074 smp->data.u.sint = XXH32(smp->data.u.str.area, smp->data.u.str.data,
2075 seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002076 smp->data.type = SMP_T_SINT;
2077 return 1;
2078}
2079
2080/* hashes the binary input into a 64-bit unsigned int using xxh.
2081 * In fact, the function returns a 64 bit unsigned, but the sample
2082 * storage of haproxy only proposes 64-bits signed, so the value is
2083 * cast as signed. This cast doesn't impact the hash repartition.
2084 * The seed of the hash defaults to 0 but can be changd in argument 1.
2085 */
2086static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
2087{
2088 unsigned long long int seed;
2089
2090 if (arg_p && arg_p->data.sint)
2091 seed = (unsigned long long int)arg_p->data.sint;
2092 else
2093 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002094 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.area,
2095 smp->data.u.str.data, seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002096 smp->data.type = SMP_T_SINT;
2097 return 1;
2098}
2099
Willy Tarreau80599772015-01-20 19:35:24 +01002100/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002101static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002102{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002103 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2104 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002105 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002106 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002107 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002108 return 1;
2109}
2110
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002111/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2112static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2113{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002114 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2115 smp->data.u.str.data);
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002116 if (arg_p && arg_p->data.sint)
2117 smp->data.u.sint = full_hash(smp->data.u.sint);
2118 smp->data.type = SMP_T_SINT;
2119 return 1;
2120}
2121
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002122/* This function escape special json characters. The returned string can be
2123 * safely set between two '"' and used as json string. The json string is
2124 * defined like this:
2125 *
2126 * any Unicode character except '"' or '\' or control character
2127 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2128 *
2129 * The enum input_type contain all the allowed mode for decoding the input
2130 * string.
2131 */
2132enum input_type {
2133 IT_ASCII = 0,
2134 IT_UTF8,
2135 IT_UTF8S,
2136 IT_UTF8P,
2137 IT_UTF8PS,
2138};
2139static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2140 const char *file, int line, char **err)
2141{
2142 if (!arg) {
2143 memprintf(err, "Unexpected empty arg list");
2144 return 0;
2145 }
2146
2147 if (arg->type != ARGT_STR) {
2148 memprintf(err, "Unexpected arg type");
2149 return 0;
2150 }
2151
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002152 if (strcmp(arg->data.str.area, "") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002153 arg->type = ARGT_SINT;
2154 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002155 return 1;
2156 }
2157
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002158 else if (strcmp(arg->data.str.area, "ascii") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002159 arg->type = ARGT_SINT;
2160 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002161 return 1;
2162 }
2163
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002164 else if (strcmp(arg->data.str.area, "utf8") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002165 arg->type = ARGT_SINT;
2166 arg->data.sint = IT_UTF8;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002167 return 1;
2168 }
2169
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002170 else if (strcmp(arg->data.str.area, "utf8s") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002171 arg->type = ARGT_SINT;
2172 arg->data.sint = IT_UTF8S;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002173 return 1;
2174 }
2175
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002176 else if (strcmp(arg->data.str.area, "utf8p") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002177 arg->type = ARGT_SINT;
2178 arg->data.sint = IT_UTF8P;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002179 return 1;
2180 }
2181
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002182 else if (strcmp(arg->data.str.area, "utf8ps") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002183 arg->type = ARGT_SINT;
2184 arg->data.sint = IT_UTF8PS;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002185 return 1;
2186 }
2187
Thierry FOURNIER / OZON.IOa69c9122016-11-23 01:13:57 +01002188 memprintf(err, "Unexpected input code type. "
2189 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002190 return 0;
2191}
2192
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002193static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002194{
Willy Tarreau83061a82018-07-13 11:56:34 +02002195 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002196 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2197 const char *str;
2198 int len;
2199 enum input_type input_type = IT_ASCII;
2200 unsigned int c;
2201 unsigned int ret;
2202 char *p;
2203
2204 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002205 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002206
2207 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002208 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002209
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002210 p = smp->data.u.str.area;
2211 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002212
2213 if (input_type == IT_ASCII) {
2214 /* Read input as ASCII. */
2215 c = *(unsigned char *)p;
2216 p++;
2217 }
2218 else {
2219 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002220 ret = utf8_next(p,
2221 smp->data.u.str.data - ( p - smp->data.u.str.area),
2222 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002223 p += utf8_return_length(ret);
2224
2225 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2226 return 0;
2227 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2228 continue;
2229 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2230 return 0;
2231 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2232 continue;
2233
2234 /* Check too big values. */
2235 if ((unsigned int)c > 0xffff) {
2236 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2237 return 0;
2238 continue;
2239 }
2240 }
2241
2242 /* Convert character. */
2243 if (c == '"') {
2244 len = 2;
2245 str = "\\\"";
2246 }
2247 else if (c == '\\') {
2248 len = 2;
2249 str = "\\\\";
2250 }
2251 else if (c == '/') {
2252 len = 2;
2253 str = "\\/";
2254 }
2255 else if (c == '\b') {
2256 len = 2;
2257 str = "\\b";
2258 }
2259 else if (c == '\f') {
2260 len = 2;
2261 str = "\\f";
2262 }
2263 else if (c == '\r') {
2264 len = 2;
2265 str = "\\r";
2266 }
2267 else if (c == '\n') {
2268 len = 2;
2269 str = "\\n";
2270 }
2271 else if (c == '\t') {
2272 len = 2;
2273 str = "\\t";
2274 }
Willy Tarreau90807112020-02-25 08:16:33 +01002275 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002276 /* isprint generate a segfault if c is too big. The man says that
2277 * c must have the value of an unsigned char or EOF.
2278 */
2279 len = 6;
2280 _str[0] = '\\';
2281 _str[1] = 'u';
2282 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2283 str = _str;
2284 }
2285 else {
2286 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002287 _str[0] = c;
2288 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002289 }
2290
2291 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002292 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002293 return 0;
2294
2295 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002296 memcpy(temp->area + temp->data, str, len);
2297 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002298 }
2299
2300 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002301 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002302 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002303
2304 return 1;
2305}
2306
Emeric Brun54c4ac82014-11-03 15:32:43 +01002307/* This sample function is designed to extract some bytes from an input buffer.
2308 * First arg is the offset.
2309 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002310static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002311{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002312 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2313 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002314 return 1;
2315 }
2316
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002317 if (smp->data.u.str.size)
2318 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002319 smp->data.u.str.data -= arg_p[0].data.sint;
2320 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002321
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002322 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2323 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002324
2325 return 1;
2326}
2327
Emeric Brunf399b0d2014-11-03 17:07:03 +01002328static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2329 const char *file, int line, char **err)
2330{
2331 struct arg *arg = args;
2332
2333 if (!arg) {
2334 memprintf(err, "Unexpected empty arg list");
2335 return 0;
2336 }
2337
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002338 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002339 memprintf(err, "Unexpected arg type");
2340 return 0;
2341 }
2342
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002343 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002344 memprintf(err, "Unexpected value 0 for index");
2345 return 0;
2346 }
2347
2348 arg++;
2349
2350 if (arg->type != ARGT_STR) {
2351 memprintf(err, "Unexpected arg type");
2352 return 0;
2353 }
2354
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002355 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002356 memprintf(err, "Empty separators list");
2357 return 0;
2358 }
2359
2360 return 1;
2361}
2362
2363/* This sample function is designed to a return selected part of a string (field).
2364 * First arg is the index of the field (start at 1)
2365 * Second arg is a char list of separators (type string)
2366 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002367static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002368{
Marcin Deranek9631a282018-04-16 14:30:46 +02002369 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002370 char *start, *end;
2371 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002372 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002373
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002374 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002375 return 0;
2376
Marcin Deranek9631a282018-04-16 14:30:46 +02002377 if (arg_p[0].data.sint < 0) {
2378 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002379 end = start = smp->data.u.str.area + smp->data.u.str.data;
2380 while (start > smp->data.u.str.area) {
2381 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2382 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002383 if (field == arg_p[0].data.sint) {
2384 if (count == 1)
2385 goto found;
2386 else if (count > 1)
2387 count--;
2388 } else {
2389 end = start-1;
2390 field--;
2391 }
2392 break;
2393 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002394 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002395 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002396 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002397 } else {
2398 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002399 end = start = smp->data.u.str.area;
2400 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2401 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2402 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002403 if (field == arg_p[0].data.sint) {
2404 if (count == 1)
2405 goto found;
2406 else if (count > 1)
2407 count--;
2408 } else {
2409 start = end+1;
2410 field++;
2411 }
2412 break;
2413 }
2414 }
2415 end++;
2416 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002417 }
2418
2419 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002420 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002421 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002422 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002423 }
2424found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002425 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002426 /* If ret string is len 0, no need to
2427 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002428 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002429 return 1;
2430
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002431 smp->data.u.str.area = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002432
2433 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002434 Note: smp->data.u.str.size cannot be set to 0 */
2435 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002436 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002437
2438 return 1;
2439}
2440
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002441/* This sample function is designed to return a word from a string.
2442 * First arg is the index of the word (start at 1)
2443 * Second arg is a char list of words separators (type string)
2444 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002445static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002446{
Marcin Deranek9631a282018-04-16 14:30:46 +02002447 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002448 char *start, *end;
2449 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002450 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002451
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002452 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002453 return 0;
2454
2455 word = 0;
2456 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002457 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002458 end = start = smp->data.u.str.area + smp->data.u.str.data;
2459 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002460 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002461 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2462 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002463 issep = 1;
2464 break;
2465 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002466 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002467 if (!inword) {
2468 if (!issep) {
2469 if (word != arg_p[0].data.sint) {
2470 word--;
2471 end = start;
2472 }
2473 inword = 1;
2474 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002475 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002476 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002477 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002478 if (count == 1)
2479 goto found;
2480 else if (count > 1)
2481 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002482 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002483 inword = 0;
2484 }
2485 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002486 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002487 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002488 end = start = smp->data.u.str.area;
2489 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002490 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002491 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2492 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002493 issep = 1;
2494 break;
2495 }
2496 }
2497 if (!inword) {
2498 if (!issep) {
2499 if (word != arg_p[0].data.sint) {
2500 word++;
2501 start = end;
2502 }
2503 inword = 1;
2504 }
2505 }
2506 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002507 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002508 if (count == 1)
2509 goto found;
2510 else if (count > 1)
2511 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002512 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002513 inword = 0;
2514 }
2515 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002516 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002517 }
2518
2519 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002520 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002521 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002522 return 1;
2523 }
2524found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002525 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002526 /* If ret string is len 0, no need to
2527 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002528 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002529 return 1;
2530
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002531 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002532
2533 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002534 Note: smp->data.u.str.size cannot be set to 0 */
2535 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002536 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002537
2538 return 1;
2539}
2540
Willy Tarreau7eda8492015-01-20 19:47:06 +01002541static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2542 const char *file, int line, char **err)
2543{
2544 struct arg *arg = args;
2545 char *p;
2546 int len;
2547
2548 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2549 arg[0].type_flags = 0;
2550
2551 if (arg[2].type != ARGT_STR)
2552 return 1;
2553
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002554 p = arg[2].data.str.area;
2555 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002556 while (len) {
2557 if (*p == 'i') {
2558 arg[0].type_flags |= ARGF_REG_ICASE;
2559 }
2560 else if (*p == 'g') {
2561 arg[0].type_flags |= ARGF_REG_GLOB;
2562 }
2563 else {
2564 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2565 return 0;
2566 }
2567 p++;
2568 len--;
2569 }
2570 return 1;
2571}
2572
2573/* This sample function is designed to do the equivalent of s/match/replace/ on
2574 * the input string. It applies a regex and restarts from the last matched
2575 * location until nothing matches anymore. First arg is the regex to apply to
2576 * the input string, second arg is the replacement expression.
2577 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002578static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002579{
2580 char *start, *end;
2581 struct my_regex *reg = arg_p[0].data.reg;
2582 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002583 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002584 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002585 int flag, max;
2586 int found;
2587
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002588 start = smp->data.u.str.area;
2589 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002590
2591 flag = 0;
2592 while (1) {
2593 /* check for last round which is used to copy remaining parts
2594 * when not running in global replacement mode.
2595 */
2596 found = 0;
2597 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2598 /* Note: we can have start == end on empty strings or at the end */
2599 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2600 }
2601
2602 if (!found)
2603 pmatch[0].rm_so = end - start;
2604
2605 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002606 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002607 if (max && pmatch[0].rm_so > 0) {
2608 if (max > pmatch[0].rm_so)
2609 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002610 memcpy(trash->area + trash->data, start, max);
2611 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002612 }
2613
2614 if (!found)
2615 break;
2616
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002617 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002618 if (!output)
2619 break;
2620
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002621 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2622
Willy Tarreau7eda8492015-01-20 19:47:06 +01002623 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002624 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002625 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002626 if (max > output->data)
2627 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002628 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002629 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002630 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002631 }
2632
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002633 free_trash_chunk(output);
2634
Willy Tarreau7eda8492015-01-20 19:47:06 +01002635 /* stop here if we're done with this string */
2636 if (start >= end)
2637 break;
2638
2639 /* We have a special case for matches of length 0 (eg: "x*y*").
2640 * These ones are considered to match in front of a character,
2641 * so we have to copy that character and skip to the next one.
2642 */
2643 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002644 if (trash->data < trash->size)
2645 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002646 pmatch[0].rm_eo++;
2647 }
2648
2649 start += pmatch[0].rm_eo;
2650 flag |= REG_NOTBOL;
2651 }
2652
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002653 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002654 return 1;
2655}
2656
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002657/* This function check an operator entry. It expects a string.
2658 * The string can be an integer or a variable name.
2659 */
2660static int check_operator(struct arg *args, struct sample_conv *conv,
2661 const char *file, int line, char **err)
2662{
2663 const char *str;
2664 const char *end;
2665
2666 /* Try to decode a variable. */
2667 if (vars_check_arg(&args[0], NULL))
2668 return 1;
2669
2670 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002671 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002672 end = str + strlen(str);
2673 args[0].data.sint = read_int64(&str, end);
2674 if (*str != '\0') {
2675 memprintf(err, "expects an integer or a variable name");
2676 return 0;
2677 }
2678 args[0].type = ARGT_SINT;
2679 return 1;
2680}
2681
Willy Tarreau6204cd92016-03-10 16:33:04 +01002682/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002683 * If the arg contain an integer, the integer is returned in the
2684 * sample. If the arg contains a variable descriptor, it returns the
2685 * variable value.
2686 *
2687 * This function returns 0 if an error occurs, otherwise it returns 1.
2688 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002689static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002690{
2691 switch (arg->type) {
2692 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002693 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002694 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002695 return 1;
2696 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002697 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002698 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002699 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002700 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002701 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002702 return 0;
2703 return 1;
2704 default:
2705 return 0;
2706 }
2707}
2708
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002709/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002710 * result.
2711 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002712static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002713{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002714 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002715 return 1;
2716}
2717
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002718/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002719 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002720 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002721static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002722{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002723 struct sample tmp;
2724
Willy Tarreau7560dd42016-03-10 16:28:58 +01002725 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002726 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002727 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002728 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002729 return 1;
2730}
2731
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002732/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002733 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002734 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002735static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002736{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002737 struct sample tmp;
2738
Willy Tarreau7560dd42016-03-10 16:28:58 +01002739 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002740 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002741 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002742 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002743 return 1;
2744}
2745
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002746/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002747 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002748 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002749static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002750{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002751 struct sample tmp;
2752
Willy Tarreau7560dd42016-03-10 16:28:58 +01002753 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002754 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002755 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002756 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002757 return 1;
2758}
2759
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002760static inline long long int arith_add(long long int a, long long int b)
2761{
2762 /* Prevent overflow and makes capped calculus.
2763 * We must ensure that the check calculus doesn't
2764 * exceed the signed 64 bits limits.
2765 *
2766 * +----------+----------+
2767 * | a<0 | a>=0 |
2768 * +------+----------+----------+
2769 * | b<0 | MIN-a>b | no check |
2770 * +------+----------+----------+
2771 * | b>=0 | no check | MAX-a<b |
2772 * +------+----------+----------+
2773 */
2774 if ((a ^ b) >= 0) {
2775 /* signs are differents. */
2776 if (a < 0) {
2777 if (LLONG_MIN - a > b)
2778 return LLONG_MIN;
2779 }
2780 if (LLONG_MAX - a < b)
2781 return LLONG_MAX;
2782 }
2783 return a + b;
2784}
2785
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002786/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002787 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002788 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002789static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002790{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002791 struct sample tmp;
2792
Willy Tarreau7560dd42016-03-10 16:28:58 +01002793 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002794 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002795 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002796 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002797 return 1;
2798}
2799
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002800/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002801 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002802 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002803static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002804 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002805{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002806 struct sample tmp;
2807
Willy Tarreau7560dd42016-03-10 16:28:58 +01002808 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002809 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002810 return 0;
2811
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002812 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2813 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2814 * of -LLONG_MIN and correct the result.
2815 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002816 if (tmp.data.u.sint == LLONG_MIN) {
2817 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2818 if (smp->data.u.sint < LLONG_MAX)
2819 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002820 return 1;
2821 }
2822
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002823 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002824 * the second operand.
2825 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002826 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002827 return 1;
2828}
2829
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002830/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002831 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002832 * If the result makes an overflow, then the largest possible quantity is
2833 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002834 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002835static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002836 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002837{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002838 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002839 long long int c;
2840
Willy Tarreau7560dd42016-03-10 16:28:58 +01002841 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002842 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002843 return 0;
2844
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002845 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002846 if (!smp->data.u.sint || !tmp.data.u.sint) {
2847 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002848 return 1;
2849 }
2850
2851 /* The multiply between LLONG_MIN and -1 returns a
2852 * "floting point exception".
2853 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002854 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2855 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002856 return 1;
2857 }
2858
2859 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002860 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002861
2862 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002863 if (smp->data.u.sint != c / tmp.data.u.sint) {
2864 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2865 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002866 return 1;
2867 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002868 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002869 return 1;
2870 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002871 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002872 return 1;
2873}
2874
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002875/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002876 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002877 * If arg_p makes the result overflow, then the largest possible quantity is
2878 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002879 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002880static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002881 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002882{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002883 struct sample tmp;
2884
Willy Tarreau7560dd42016-03-10 16:28:58 +01002885 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002886 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002887 return 0;
2888
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002889 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002890 /* The divide between LLONG_MIN and -1 returns a
2891 * "floting point exception".
2892 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002893 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2894 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002895 return 1;
2896 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002897 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002898 return 1;
2899 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002900 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002901 return 1;
2902}
2903
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002904/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002905 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002906 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002907 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002908static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002909 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002910{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002911 struct sample tmp;
2912
Willy Tarreau7560dd42016-03-10 16:28:58 +01002913 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002914 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002915 return 0;
2916
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002917 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002918 /* The divide between LLONG_MIN and -1 returns a
2919 * "floting point exception".
2920 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002921 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2922 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002923 return 1;
2924 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002925 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002926 return 1;
2927 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002928 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002929 return 1;
2930}
2931
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002932/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002933 * result.
2934 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002935static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002936 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002937{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002938 if (smp->data.u.sint == LLONG_MIN)
2939 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002940 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002941 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002942 return 1;
2943}
2944
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002945/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002946 * false. The output is a BOOL.
2947 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002948static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002949 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002950{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002951 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002952 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002953 return 1;
2954}
2955
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002956/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002957 * truee. The output is a BOOL.
2958 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002959static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002960 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002961{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002962 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002963 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002964 return 1;
2965}
2966
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002967/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002968 * The output is a BOOL.
2969 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002970static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002971 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002972{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002973 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002974 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002975 return 1;
2976}
2977
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002978/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002979 * The output is a BOOL.
2980 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002981static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002982 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002983{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002984 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002985 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002986 return 1;
2987}
2988
Willy Tarreau280f42b2018-02-19 15:34:12 +01002989/* appends an optional const string, an optional variable contents and another
2990 * optional const string to an existing string.
2991 */
2992static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
2993{
Willy Tarreau83061a82018-07-13 11:56:34 +02002994 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002995 struct sample tmp;
2996 int max;
2997
2998 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002999 trash->data = smp->data.u.str.data;
3000 if (trash->data > trash->size - 1)
3001 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003002
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003003 memcpy(trash->area, smp->data.u.str.area, trash->data);
3004 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003005
3006 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003007 max = arg_p[0].data.str.data;
3008 if (max > trash->size - 1 - trash->data)
3009 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003010
3011 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003012 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3013 trash->data += max;
3014 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003015 }
3016
3017 /* append second string (variable) if it's found and we can turn it
3018 * into a string.
3019 */
3020 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3021 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3022 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3023 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3024
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003025 max = tmp.data.u.str.data;
3026 if (max > trash->size - 1 - trash->data)
3027 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003028
3029 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003030 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3031 max);
3032 trash->data += max;
3033 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003034 }
3035 }
3036
3037 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003038 max = arg_p[2].data.str.data;
3039 if (max > trash->size - 1 - trash->data)
3040 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003041
3042 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003043 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3044 trash->data += max;
3045 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003046 }
3047
3048 smp->data.u.str = *trash;
3049 smp->data.type = SMP_T_STR;
3050 return 1;
3051}
3052
3053/* This function checks the "concat" converter's arguments and extracts the
3054 * variable name and its scope.
3055 */
3056static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3057 const char *file, int line, char **err)
3058{
3059 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003060 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3061 memprintf(err, "failed to register variable name '%s'",
3062 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003063 return 0;
3064 }
3065 return 1;
3066}
3067
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003068/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003069 * is compatible with strcmp(3)'s return value.
3070 */
3071static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3072{
3073 struct sample tmp;
3074 int max, result;
3075
3076 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3077 if (arg_p[0].type != ARGT_VAR)
3078 return 0;
3079 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3080 return 0;
3081 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3082 return 0;
3083
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003084 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3085 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003086 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003087 if (smp->data.u.str.data != tmp.data.u.str.data) {
3088 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003089 result = -1;
3090 }
3091 else {
3092 result = 1;
3093 }
3094 }
3095 }
3096
3097 smp->data.u.sint = result;
3098 smp->data.type = SMP_T_SINT;
3099 return 1;
3100}
3101
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003102#ifdef USE_OPENSSL
3103/* Compares bytestring with a variable containing a bytestring. Return value
3104 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3105 *
3106 * Comparison will be performed in constant time if both bytestrings are of
3107 * the same length. If the lengths differ execution time will not be constant.
3108 */
3109static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3110{
3111 struct sample tmp;
3112 int result;
3113
3114 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3115 if (arg_p[0].type != ARGT_VAR)
3116 return 0;
3117 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3118 return 0;
3119 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3120 return 0;
3121
3122 if (smp->data.u.str.data != tmp.data.u.str.data) {
3123 smp->data.u.sint = 0;
3124 smp->data.type = SMP_T_BOOL;
3125 return 1;
3126 }
3127
3128 /* The following comparison is performed in constant time. */
3129 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3130
3131 smp->data.u.sint = result == 0;
3132 smp->data.type = SMP_T_BOOL;
3133 return 1;
3134}
3135#endif
3136
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003137#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3138#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3139#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3140
3141/*
3142 * Extract the field value of an input binary sample. Takes a mandatory argument:
3143 * the protocol buffers field identifier (dotted notation) internally represented
3144 * as an array of unsigned integers and its size.
3145 * Return 1 if the field was found, 0 if not.
3146 */
3147static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3148{
3149 unsigned char *pos;
3150 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003151
3152 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003153 grpc_left = smp->data.u.str.data;
3154
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003155 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003156 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003157
3158 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3159
3160 pos += GRPC_MSG_HEADER_SZ;
3161 grpc_left -= GRPC_MSG_HEADER_SZ;
3162
3163 if (grpc_left < left)
3164 return 0;
3165
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003166 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3167 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003168
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003169 grpc_left -= grpc_msg_len;
3170 }
3171
3172 return 0;
3173}
3174
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003175static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3176{
3177 unsigned char *pos;
3178 size_t left;
3179
3180 pos = (unsigned char *)smp->data.u.str.area;
3181 left = smp->data.u.str.data;
3182
3183 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3184}
3185
3186static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3187 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003188{
3189 if (!args[1].type) {
3190 args[1].type = ARGT_SINT;
3191 args[1].data.sint = PBUF_T_BINARY;
3192 }
3193 else {
3194 int pbuf_type;
3195
3196 pbuf_type = protobuf_type(args[1].data.str.area);
3197 if (pbuf_type == -1) {
3198 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3199 return 0;
3200 }
3201
3202 args[1].type = ARGT_SINT;
3203 args[1].data.sint = pbuf_type;
3204 }
3205
3206 return 1;
3207}
3208
Tim Duesterhusca097c12018-04-27 21:18:45 +02003209/* This function checks the "strcmp" converter's arguments and extracts the
3210 * variable name and its scope.
3211 */
3212static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3213 const char *file, int line, char **err)
3214{
3215 /* Try to decode a variable. */
3216 if (vars_check_arg(&args[0], NULL))
3217 return 1;
3218
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003219 memprintf(err, "failed to register variable name '%s'",
3220 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003221 return 0;
3222}
3223
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003224#ifdef USE_OPENSSL
3225/* This function checks the "secure_memcmp" converter's arguments and extracts the
3226 * variable name and its scope.
3227 */
3228static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3229 const char *file, int line, char **err)
3230{
3231 /* Try to decode a variable. */
3232 if (vars_check_arg(&args[0], NULL))
3233 return 1;
3234
3235 memprintf(err, "failed to register variable name '%s'",
3236 args[0].data.str.area);
3237 return 0;
3238}
3239#endif
3240
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003241/**/
3242static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3243{
3244 struct buffer *tmp;
3245 uint32_t n;
3246
3247 n = htonl((uint32_t)smp->data.u.sint);
3248 tmp = get_trash_chunk();
3249
3250 memcpy(b_head(tmp), &n, 4);
3251 b_add(tmp, 4);
3252
3253 smp->data.u.str = *tmp;
3254 smp->data.type = SMP_T_BIN;
3255 return 1;
3256}
3257
Christopher Fauletea159d62020-04-01 16:21:44 +02003258/**/
3259static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3260{
3261 char *p;
3262 size_t l;
3263
3264 p = smp->data.u.str.area;
3265 for (l = 0; l < smp->data.u.str.data; l++) {
3266 if (*(p+l) == '\r' || *(p+l) == '\n')
3267 break;
3268 }
3269 smp->data.u.str.data = l;
3270 return 1;
3271}
3272
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003273/**/
3274static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3275{
3276 char *delimiters, *p;
3277 size_t dlen, l;
3278
3279 delimiters = arg_p[0].data.str.area;
3280 dlen = arg_p[0].data.str.data;
3281
3282 l = smp->data.u.str.data;
3283 p = smp->data.u.str.area;
3284 while (l && memchr(delimiters, *p, dlen) != NULL) {
3285 p++;
3286 l--;
3287 }
3288
3289 smp->data.u.str.area = p;
3290 smp->data.u.str.data = l;
3291 return 1;
3292}
3293
Christopher Faulet568415a2020-04-01 17:24:47 +02003294/**/
3295static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3296{
3297 char *delimiters, *p;
3298 size_t dlen, l;
3299
3300 delimiters = arg_p[0].data.str.area;
3301 dlen = arg_p[0].data.str.data;
3302
3303 l = smp->data.u.str.data;
3304 p = smp->data.u.str.area + l - 1;
3305 while (l && memchr(delimiters, *p, dlen) != NULL) {
3306 p--;
3307 l--;
3308 }
3309
3310 smp->data.u.str.data = l;
3311 return 1;
3312}
3313
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003314/************************************************************************/
3315/* All supported sample fetch functions must be declared here */
3316/************************************************************************/
3317
3318/* force TRUE to be returned at the fetch level */
3319static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003320smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003321{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003322 if (!smp_make_rw(smp))
3323 return 0;
3324
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003325 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003326 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003327 return 1;
3328}
3329
3330/* force FALSE to be returned at the fetch level */
3331static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003332smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003333{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003334 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003335 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003336 return 1;
3337}
3338
3339/* retrieve environment variable $1 as a string */
3340static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003341smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003342{
3343 char *env;
3344
3345 if (!args || args[0].type != ARGT_STR)
3346 return 0;
3347
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003348 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003349 if (!env)
3350 return 0;
3351
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003352 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003353 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003354 smp->data.u.str.area = env;
3355 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003356 return 1;
3357}
3358
Damien Claisseae6f1252019-10-30 15:57:28 +00003359/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3360 * optional string representing the unit of the result: "s" for seconds, "ms" for
3361 * milliseconds and "us" for microseconds.
3362 * Returns 0 on error and non-zero if OK.
3363 */
3364int smp_check_date_unit(struct arg *args, char **err)
3365{
3366 if (args[1].type == ARGT_STR) {
3367 if (strcmp(args[1].data.str.area, "s") == 0) {
3368 args[1].data.sint = TIME_UNIT_S;
3369 }
3370 else if (strcmp(args[1].data.str.area, "ms") == 0) {
3371 args[1].data.sint = TIME_UNIT_MS;
3372 }
3373 else if (strcmp(args[1].data.str.area, "us") == 0) {
3374 args[1].data.sint = TIME_UNIT_US;
3375 }
3376 else {
3377 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3378 args[1].data.str.area);
3379 return 0;
3380 }
3381 free(args[1].data.str.area);
3382 args[1].data.str.area = NULL;
3383 args[1].type = ARGT_SINT;
3384 }
3385 else if (args[1].type != ARGT_STOP) {
3386 memprintf(err, "Unexpected arg type");
3387 return 0;
3388 }
3389
3390 return 1;
3391}
3392
3393/* retrieve the current local date in epoch time, converts it to milliseconds
3394 * or microseconds if asked to in optional args[1] unit param, and applies an
3395 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003396 */
3397static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003398smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003399{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003400 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003401
Damien Claisseae6f1252019-10-30 15:57:28 +00003402 /* report in milliseconds */
3403 if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
3404 smp->data.u.sint *= 1000;
3405 smp->data.u.sint += date.tv_usec / 1000;
3406 }
3407 /* report in microseconds */
3408 else if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
3409 smp->data.u.sint *= 1000000;
3410 smp->data.u.sint += date.tv_usec;
3411 }
3412
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003413 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003414 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003415 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003416
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003417 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003418 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3419 return 1;
3420}
3421
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003422/* retrieve the current microsecond part of the date */
3423static int
3424smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3425{
3426 smp->data.u.sint = date.tv_usec;
3427 smp->data.type = SMP_T_SINT;
3428 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3429 return 1;
3430}
3431
3432
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003433/* returns the hostname */
3434static int
3435smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3436{
3437 smp->data.type = SMP_T_STR;
3438 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003439 smp->data.u.str.area = hostname;
3440 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003441 return 1;
3442}
3443
Willy Tarreau0f30d262014-11-24 16:02:05 +01003444/* returns the number of processes */
3445static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003446smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003447{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003448 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003449 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003450 return 1;
3451}
3452
3453/* returns the number of the current process (between 1 and nbproc */
3454static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003455smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003456{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003457 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003458 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003459 return 1;
3460}
3461
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003462/* returns the number of the current thread (between 1 and nbthread */
3463static int
3464smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3465{
3466 smp->data.type = SMP_T_SINT;
3467 smp->data.u.sint = tid;
3468 return 1;
3469}
3470
Willy Tarreau84310e22014-02-14 11:59:04 +01003471/* generate a random 32-bit integer for whatever purpose, with an optional
3472 * range specified in argument.
3473 */
3474static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003475smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003476{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003477 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003478
3479 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003480 if (args && args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003481 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003482
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003483 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003484 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3485 return 1;
3486}
3487
Willy Tarreau0f30d262014-11-24 16:02:05 +01003488/* returns true if the current process is stopping */
3489static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003490smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003491{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003492 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003493 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003494 return 1;
3495}
3496
Willy Tarreau70fe9442018-11-22 16:07:39 +01003497/* returns the number of calls of the current stream's process_stream() */
3498static int
3499smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
3500{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003501 if (!smp->strm)
3502 return 0;
3503
Willy Tarreau70fe9442018-11-22 16:07:39 +01003504 smp->data.type = SMP_T_SINT;
3505 smp->data.u.sint = smp->strm->task->calls;
3506 return 1;
3507}
3508
3509/* returns the average number of nanoseconds spent processing the stream per call */
3510static int
3511smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3512{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003513 if (!smp->strm)
3514 return 0;
3515
Willy Tarreau70fe9442018-11-22 16:07:39 +01003516 smp->data.type = SMP_T_SINT;
3517 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
3518 return 1;
3519}
3520
3521/* returns the total number of nanoseconds spent processing the stream */
3522static int
3523smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3524{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003525 if (!smp->strm)
3526 return 0;
3527
Willy Tarreau70fe9442018-11-22 16:07:39 +01003528 smp->data.type = SMP_T_SINT;
3529 smp->data.u.sint = smp->strm->task->cpu_time;
3530 return 1;
3531}
3532
3533/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
3534static int
3535smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3536{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003537 if (!smp->strm)
3538 return 0;
3539
Willy Tarreau70fe9442018-11-22 16:07:39 +01003540 smp->data.type = SMP_T_SINT;
3541 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
3542 return 1;
3543}
3544
3545/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
3546static int
3547smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3548{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003549 if (!smp->strm)
3550 return 0;
3551
Willy Tarreau70fe9442018-11-22 16:07:39 +01003552 smp->data.type = SMP_T_SINT;
3553 smp->data.u.sint = smp->strm->task->lat_time;
3554 return 1;
3555}
3556
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003557static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
3558{
3559 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003560 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003561 smp->data.u.str.area = args[0].data.str.area;
3562 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003563 return 1;
3564}
3565
3566static int smp_check_const_bool(struct arg *args, char **err)
3567{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003568 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
3569 strcasecmp(args[0].data.str.area, "1") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003570 args[0].type = ARGT_SINT;
3571 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003572 return 1;
3573 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003574 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
3575 strcasecmp(args[0].data.str.area, "0") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003576 args[0].type = ARGT_SINT;
3577 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003578 return 1;
3579 }
3580 memprintf(err, "Expects 'true', 'false', '0' or '1'");
3581 return 0;
3582}
3583
3584static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
3585{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003586 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003587 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003588 return 1;
3589}
3590
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003591static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003592{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003593 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003594 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003595 return 1;
3596}
3597
3598static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
3599{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003600 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003601 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003602 return 1;
3603}
3604
3605static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
3606{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003607 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003608 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003609 return 1;
3610}
3611
3612static int smp_check_const_bin(struct arg *args, char **err)
3613{
David Carlier64a16ab2016-04-08 10:37:02 +01003614 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003615 int binstrlen;
3616
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003617 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003618 return 0;
3619 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003620 args[0].data.str.area = binstr;
3621 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003622 return 1;
3623}
3624
3625static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
3626{
3627 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003628 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003629 smp->data.u.str.area = args[0].data.str.area;
3630 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003631 return 1;
3632}
3633
3634static int smp_check_const_meth(struct arg *args, char **err)
3635{
3636 enum http_meth_t meth;
3637 int i;
3638
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003639 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003640 if (meth != HTTP_METH_OTHER) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003641 args[0].type = ARGT_SINT;
3642 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003643 } else {
3644 /* Check method avalaibility. A methos is a token defined as :
3645 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
3646 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
3647 * token = 1*tchar
3648 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003649 for (i = 0; i < args[0].data.str.data; i++) {
3650 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003651 memprintf(err, "expects valid method.");
3652 return 0;
3653 }
3654 }
3655 }
3656 return 1;
3657}
3658
3659static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
3660{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003661 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003662 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003663 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003664 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003665 smp->data.u.meth.str.area = "";
3666 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003667 } else {
3668 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003669 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003670 smp->data.u.meth.str.area = args[0].data.str.area;
3671 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003672 }
3673 return 1;
3674}
3675
Luca Schimweg8a694b82019-09-10 15:42:52 +02003676// This function checks the "uuid" sample's arguments.
3677// Function won't get called when no parameter is specified (maybe a bug?)
3678static int smp_check_uuid(struct arg *args, char **err)
3679{
3680 if (!args[0].type) {
3681 args[0].type = ARGT_SINT;
3682 args[0].data.sint = 4;
3683 }
3684 else if (args[0].data.sint != 4) {
3685 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
3686 return 0;
3687 }
3688
3689 return 1;
3690}
3691
3692// Generate a RFC4122 UUID (default is v4 = fully random)
3693static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
3694{
3695 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01003696 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02003697 smp->data.type = SMP_T_STR;
3698 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3699 smp->data.u.str = trash;
3700 return 1;
3701 }
3702
3703 // more implementations of other uuid formats possible here
3704 return 0;
3705}
3706
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003707/* Note: must not be declared <const> as its list will be overwritten.
3708 * Note: fetches that may return multiple types must be declared as the lowest
3709 * common denominator, the type that can be casted into all other ones. For
3710 * instance IPv4/IPv6 must be declared IPv4.
3711 */
3712static struct sample_fetch_kw_list smp_kws = {ILH, {
3713 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
3714 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003715 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Damien Claisseae6f1252019-10-30 15:57:28 +00003716 { "date", smp_fetch_date, ARG2(0,SINT,STR), smp_check_date_unit, SMP_T_SINT, SMP_USE_INTRN },
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003717 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003718 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003719 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3720 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003721 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003722 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01003723 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003724 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Luca Schimweg8a694b82019-09-10 15:42:52 +02003725 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003726
3727 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3728 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3729 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3730 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3731 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003732
3733 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
3734 { "bool", smp_fetch_const_bool, ARG1(1,STR), smp_check_const_bool, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003735 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003736 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
3737 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
3738 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
3739 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
3740
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003741 { /* END */ },
3742}};
3743
Willy Tarreau0108d902018-11-25 19:14:37 +01003744INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3745
Emeric Brun107ca302010-01-04 16:16:05 +01003746/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003747static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau0851fd52019-12-17 10:07:25 +01003748 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
Holger Just1bfc24b2017-05-06 00:56:53 +02003749 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02003750 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02003751 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
3752 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01003753 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01003754 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02003755 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01003756 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003757 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
3758 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003759 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01003760 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003761 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3762 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3763 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01003764 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3765 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003766 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003767 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
Marcin Deranek9631a282018-04-16 14:30:46 +02003768 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
3769 { "word", sample_conv_word, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
Willy Tarreau7eda8492015-01-20 19:47:06 +01003770 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02003771 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003772#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01003773 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02003774#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
3775 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
3776#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02003777 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
3778 { "hmac", sample_conv_crypto_hmac, ARG2(2,STR,STR), check_crypto_hmac, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003779#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01003780 { "concat", sample_conv_concat, ARG3(1,STR,STR,STR), smp_check_concat, SMP_T_STR, SMP_T_STR },
Tim Duesterhusca097c12018-04-27 21:18:45 +02003781 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003782#ifdef USE_OPENSSL
3783 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
3784#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003785
3786 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003787 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
3788 { "protobuf", sample_conv_protobuf, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
Willy Tarreau97707872015-01-27 15:12:13 +01003789
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003790 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3791 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3792 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3793 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
3794 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3795 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3796 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3797 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3798 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3799 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3800 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3801 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3802 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3803 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01003804
Christopher Fauletea159d62020-04-01 16:21:44 +02003805 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
3806 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003807 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02003808 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02003809 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01003810}};
3811
Willy Tarreau0108d902018-11-25 19:14:37 +01003812INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);