blob: 3a1534865989a3b71c7b086b87bc242121255633 [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 Tarreaub2551052020-06-09 09:07:15 +020019#include <import/sha1.h>
20#include <import/xxhash.h>
Willy Tarreau7e2c6472012-10-29 20:44:36 +010021
Willy Tarreaub2551052020-06-09 09:07:15 +020022#include <haproxy/api.h>
23#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020024#include <haproxy/auth.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020025#include <haproxy/base64.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020026#include <haproxy/buf.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020027#include <haproxy/chunk.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020028#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020029#include <haproxy/global.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020030#include <haproxy/hash.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020031#include <haproxy/http.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020032#include <haproxy/net_helper.h>
Willy Tarreaub23e5952020-06-04 16:06:59 +020033#include <haproxy/protobuf.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020034#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020035#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020036#include <haproxy/sample.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/sink.h>
38#include <haproxy/stick_table.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020039#include <haproxy/tools.h>
Willy Tarreau8c42b8a2020-06-04 19:27:34 +020040#include <haproxy/uri_auth-t.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020041#include <haproxy/vars.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010042
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
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001037 * to since they're made to cast multiple 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
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001180 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001181 arg->unresolved = 0;
1182 arg->data.srv = srv;
1183 break;
1184
1185 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001186 if (arg->data.str.data) {
1187 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001188 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001189 }
1190
1191 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001192 ha_alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1193 cur->file, cur->line, pname,
1194 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001195 cfgerr++;
1196 break;
1197 }
1198
1199 if (!(px->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001200 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",
1201 cur->file, cur->line, pname,
1202 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001203 cfgerr++;
1204 break;
1205 }
1206
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001207 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001208 arg->unresolved = 0;
1209 arg->data.prx = px;
1210 break;
1211
1212 case ARGT_BE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001213 if (arg->data.str.data) {
1214 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001215 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001216 }
1217
1218 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001219 ha_alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1220 cur->file, cur->line, pname,
1221 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001222 cfgerr++;
1223 break;
1224 }
1225
1226 if (!(px->cap & PR_CAP_BE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001227 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1228 cur->file, cur->line, pname,
1229 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001230 cfgerr++;
1231 break;
1232 }
1233
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001234 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001235 arg->unresolved = 0;
1236 arg->data.prx = px;
1237 break;
1238
1239 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001240 if (arg->data.str.data)
1241 stktname = arg->data.str.area;
1242 else
1243 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001244
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001245 t = stktable_find_by_name(stktname);
1246 if (!t) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001247 ha_alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001248 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001249 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001250 cfgerr++;
1251 break;
1252 }
1253
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001254 if (!t->size) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001255 ha_alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001256 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001257 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001258 cfgerr++;
1259 break;
1260 }
1261
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001262 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001263 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 +01001264 cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001265 cfgerr++;
1266 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001267 }
1268
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001269 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001270 p->next_stkt_ref = t->proxies_list;
1271 t->proxies_list = p;
1272 }
1273
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001274 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001275 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001276 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001277 break;
1278
1279 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001280 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001281 ha_alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1282 cur->file, cur->line,
1283 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001284 cfgerr++;
1285 break;
1286 }
1287
1288 if (p->uri_auth && p->uri_auth->userlist &&
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001289 !strcmp(p->uri_auth->userlist->name, arg->data.str.area))
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001290 ul = p->uri_auth->userlist;
1291 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001292 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001293
1294 if (!ul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001295 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 +02001296 cur->file, cur->line,
1297 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001298 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001299 cfgerr++;
1300 break;
1301 }
1302
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001303 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001304 arg->unresolved = 0;
1305 arg->data.usr = ul;
1306 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001307
1308 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001309 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001310 ha_alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1311 cur->file, cur->line,
1312 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001313 cfgerr++;
1314 continue;
1315 }
1316
Willy Tarreau46947782015-01-19 19:00:58 +01001317 rflags = 0;
1318 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1319 err = NULL;
1320
Dragan Dosen26743032019-04-30 15:54:36 +02001321 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001322 ha_alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1323 cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001324 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001325 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
Willy Tarreau46947782015-01-19 19:00:58 +01001326 cfgerr++;
1327 continue;
1328 }
1329
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001330 chunk_destroy(&arg->data.str);
Willy Tarreau46947782015-01-19 19:00:58 +01001331 arg->unresolved = 0;
1332 arg->data.reg = reg;
1333 break;
1334
1335
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001336 }
1337
1338 LIST_DEL(&cur->list);
1339 free(cur);
1340 } /* end of args processing */
1341
1342 return cfgerr;
1343}
1344
1345/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001346 * Process a fetch + format conversion as defined by the sample expression
1347 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001348 * not explicitly set to <smp_type>, but shall be compatible with it as
1349 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1350 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001351 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1352 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1353 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1354 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001355 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1356 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1357 * still hope to get it after waiting longer, and is not converted to string.
1358 * The possible output combinations are the following :
1359 *
1360 * return MAY_CHANGE FINAL Meaning for the sample
1361 * NULL * * Not present and will never be (eg: header)
1362 * smp 0 * Final value converted (eg: header)
1363 * smp 1 0 Not present yet, may appear later (eg: header)
1364 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001365 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001366struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001367 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001368 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001369{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001370 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001371
Willy Tarreau6c616e02014-06-25 16:56:41 +02001372 memset(smp, 0, sizeof(*smp));
1373
Willy Tarreau192252e2015-04-04 01:47:55 +02001374 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001375 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1376 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001377 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001378 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001379
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001380 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001381 return NULL;
1382
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001383 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001384 return NULL;
1385
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001386 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001387 return smp;
1388}
1389
Christopher Faulet476e5d02016-10-26 11:34:47 +02001390static void release_sample_arg(struct arg *p)
1391{
1392 struct arg *p_back = p;
1393
1394 if (!p)
1395 return;
1396
1397 while (p->type != ARGT_STOP) {
1398 if (p->type == ARGT_STR || p->unresolved) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001399 chunk_destroy(&p->data.str);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001400 p->unresolved = 0;
1401 }
1402 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001403 regex_free(p->data.reg);
1404 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001405 }
1406 p++;
1407 }
1408
1409 if (p_back != empty_arg_list)
1410 free(p_back);
1411}
1412
1413void release_sample_expr(struct sample_expr *expr)
1414{
1415 struct sample_conv_expr *conv_expr, *conv_exprb;
1416
1417 if (!expr)
1418 return;
1419
Tim Duesterhus867cd982020-07-04 11:49:39 +02001420 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list) {
1421 LIST_DEL(&conv_expr->list);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001422 release_sample_arg(conv_expr->arg_p);
Tim Duesterhus867cd982020-07-04 11:49:39 +02001423 free(conv_expr);
1424 }
1425
Christopher Faulet476e5d02016-10-26 11:34:47 +02001426 release_sample_arg(expr->arg_p);
1427 free(expr);
1428}
1429
Emeric Brun107ca302010-01-04 16:16:05 +01001430/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001431/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001432/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001433/*****************************************************************/
1434
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001435static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1436{
1437 int i;
1438 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001439 struct buffer *buf;
1440 struct sink *sink;
1441 struct ist line;
1442 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001443
Willy Tarreau0851fd52019-12-17 10:07:25 +01001444 buf = alloc_trash_chunk();
1445 if (!buf)
1446 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001447
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001448 sink = (struct sink *)arg_p[1].data.ptr;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001449 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001450
Willy Tarreau0851fd52019-12-17 10:07:25 +01001451 pfx = arg_p[0].data.str.area;
1452 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001453
Willy Tarreau0851fd52019-12-17 10:07:25 +01001454 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1455 if (!sample_casts[smp->data.type][SMP_T_STR])
1456 goto nocast;
1457
1458 /* Copy sample fetch. This puts the sample as const, the
1459 * cast will copy data if a transformation is required.
1460 */
1461 memcpy(&tmp, smp, sizeof(struct sample));
1462 tmp.flags = SMP_F_CONST;
1463
1464 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1465 goto nocast;
1466
1467 /* Display the displayable chars*. */
1468 b_putchr(buf, '<');
1469 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001470 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001471 b_putchr(buf, tmp.data.u.str.area[i]);
1472 else
1473 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001474 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001475 b_putchr(buf, '>');
1476
1477 done:
1478 line = ist2(buf->area, buf->data);
Emeric Brun54648852020-07-06 15:54:06 +02001479 sink_write(sink, &line, 1, 0, 0, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001480 end:
1481 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001482 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001483 nocast:
1484 chunk_appendf(buf, "(undisplayable)");
1485 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001486}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001487
1488// This function checks the "debug" converter's arguments.
1489static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1490 const char *file, int line, char **err)
1491{
1492 const char *name = "buf0";
1493 struct sink *sink = NULL;
1494
1495 if (args[0].type != ARGT_STR) {
1496 /* optional prefix */
1497 args[0].data.str.area = "";
1498 args[0].data.str.data = 0;
1499 }
1500
1501 if (args[1].type == ARGT_STR)
1502 name = args[1].data.str.area;
1503
1504 sink = sink_find(name);
1505 if (!sink) {
1506 memprintf(err, "No such sink '%s'", name);
1507 return 0;
1508 }
1509
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001510 chunk_destroy(&args[1].data.str);
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001511 args[1].type = ARGT_PTR;
1512 args[1].data.ptr = sink;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001513 return 1;
1514}
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001515
Holger Just1bfc24b2017-05-06 00:56:53 +02001516static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1517{
Willy Tarreau83061a82018-07-13 11:56:34 +02001518 struct buffer *trash = get_trash_chunk();
Holger Just1bfc24b2017-05-06 00:56:53 +02001519 int bin_len;
1520
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001521 trash->data = 0;
1522 bin_len = base64dec(smp->data.u.str.area, smp->data.u.str.data,
1523 trash->area, trash->size);
Holger Just1bfc24b2017-05-06 00:56:53 +02001524 if (bin_len < 0)
1525 return 0;
1526
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001527 trash->data = bin_len;
Holger Just1bfc24b2017-05-06 00:56:53 +02001528 smp->data.u.str = *trash;
1529 smp->data.type = SMP_T_BIN;
1530 smp->flags &= ~SMP_F_CONST;
1531 return 1;
1532}
1533
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001534static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001535{
Willy Tarreau83061a82018-07-13 11:56:34 +02001536 struct buffer *trash = get_trash_chunk();
Emeric Brun53d1a982014-04-30 18:21:37 +02001537 int b64_len;
1538
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001539 trash->data = 0;
1540 b64_len = a2base64(smp->data.u.str.area, smp->data.u.str.data,
1541 trash->area, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001542 if (b64_len < 0)
1543 return 0;
1544
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001545 trash->data = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001546 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001547 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001548 smp->flags &= ~SMP_F_CONST;
1549 return 1;
1550}
1551
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001552static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1553{
1554 blk_SHA_CTX ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001555 struct buffer *trash = get_trash_chunk();
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001556
1557 memset(&ctx, 0, sizeof(ctx));
1558
1559 blk_SHA1_Init(&ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001560 blk_SHA1_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1561 blk_SHA1_Final((unsigned char *) trash->area, &ctx);
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001562
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001563 trash->data = 20;
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001564 smp->data.u.str = *trash;
1565 smp->data.type = SMP_T_BIN;
1566 smp->flags &= ~SMP_F_CONST;
1567 return 1;
1568}
1569
Tim Duesterhusd4376302019-06-17 12:41:44 +02001570#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01001571static int smp_check_sha2(struct arg *args, struct sample_conv *conv,
1572 const char *file, int line, char **err)
1573{
1574 if (args[0].type == ARGT_STOP)
1575 return 1;
1576 if (args[0].type != ARGT_SINT) {
1577 memprintf(err, "Invalid type '%s'", arg_type_names[args[0].type]);
1578 return 0;
1579 }
1580
1581 switch (args[0].data.sint) {
1582 case 224:
1583 case 256:
1584 case 384:
1585 case 512:
1586 /* this is okay */
1587 return 1;
1588 default:
1589 memprintf(err, "Unsupported number of bits: '%lld'", args[0].data.sint);
1590 return 0;
1591 }
1592}
1593
Tim Duesterhusd4376302019-06-17 12:41:44 +02001594static int sample_conv_sha2(const struct arg *arg_p, struct sample *smp, void *private)
1595{
1596 struct buffer *trash = get_trash_chunk();
1597 int bits = 256;
1598 if (arg_p && arg_p->data.sint)
1599 bits = arg_p->data.sint;
1600
1601 switch (bits) {
1602 case 224: {
1603 SHA256_CTX ctx;
1604
1605 memset(&ctx, 0, sizeof(ctx));
1606
1607 SHA224_Init(&ctx);
1608 SHA224_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1609 SHA224_Final((unsigned char *) trash->area, &ctx);
1610 trash->data = SHA224_DIGEST_LENGTH;
1611 break;
1612 }
1613 case 256: {
1614 SHA256_CTX ctx;
1615
1616 memset(&ctx, 0, sizeof(ctx));
1617
1618 SHA256_Init(&ctx);
1619 SHA256_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1620 SHA256_Final((unsigned char *) trash->area, &ctx);
1621 trash->data = SHA256_DIGEST_LENGTH;
1622 break;
1623 }
1624 case 384: {
1625 SHA512_CTX ctx;
1626
1627 memset(&ctx, 0, sizeof(ctx));
1628
1629 SHA384_Init(&ctx);
1630 SHA384_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1631 SHA384_Final((unsigned char *) trash->area, &ctx);
1632 trash->data = SHA384_DIGEST_LENGTH;
1633 break;
1634 }
1635 case 512: {
1636 SHA512_CTX ctx;
1637
1638 memset(&ctx, 0, sizeof(ctx));
1639
1640 SHA512_Init(&ctx);
1641 SHA512_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1642 SHA512_Final((unsigned char *) trash->area, &ctx);
1643 trash->data = SHA512_DIGEST_LENGTH;
1644 break;
1645 }
1646 default:
1647 return 0;
1648 }
1649
1650 smp->data.u.str = *trash;
1651 smp->data.type = SMP_T_BIN;
1652 smp->flags &= ~SMP_F_CONST;
1653 return 1;
1654}
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001655
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001656static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
1657{
1658 switch (arg->type) {
1659 case ARGT_STR:
1660 smp->data.type = SMP_T_STR;
1661 smp->data.u.str = arg->data.str;
1662 return 1;
1663 case ARGT_VAR:
1664 if (!vars_get_by_desc(&arg->data.var, smp))
1665 return 0;
1666 if (!sample_casts[smp->data.type][SMP_T_STR])
1667 return 0;
1668 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
1669 return 0;
1670 return 1;
1671 default:
1672 return 0;
1673 }
1674}
1675
Patrick Gansterer8e366512020-04-22 16:47:57 +02001676#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001677static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
1678 const char *file, int line, char **err)
1679{
1680 switch(args[0].data.sint) {
1681 case 128:
1682 case 192:
1683 case 256:
1684 break;
1685 default:
1686 memprintf(err, "key size must be 128, 192 or 256 (bits).");
1687 return 0;
1688 }
1689 /* Try to decode a variable. */
1690 vars_check_arg(&args[1], NULL);
1691 vars_check_arg(&args[2], NULL);
1692 vars_check_arg(&args[3], NULL);
1693 return 1;
1694}
1695
1696/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
1697static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
1698{
1699 struct sample nonce, key, aead_tag;
1700 struct buffer *smp_trash, *smp_trash_alloc;
1701 EVP_CIPHER_CTX *ctx;
1702 int dec_size, ret;
1703
1704 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
1705 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
1706 return 0;
1707
1708 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1709 if (!sample_conv_var2smp_str(&arg_p[2], &key))
1710 return 0;
1711
1712 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
1713 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
1714 return 0;
1715
1716 smp_trash = get_trash_chunk();
1717 smp_trash_alloc = alloc_trash_chunk();
1718 if (!smp_trash_alloc)
1719 return 0;
1720
1721 ctx = EVP_CIPHER_CTX_new();
1722
1723 if (!ctx)
1724 goto err;
1725
1726 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
1727 if (dec_size < 0)
1728 goto err;
1729 smp_trash->data = dec_size;
1730
1731 /* Set cipher type and mode */
1732 switch(arg_p[0].data.sint) {
1733 case 128:
1734 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
1735 break;
1736 case 192:
1737 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
1738 break;
1739 case 256:
1740 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
1741 break;
1742 }
1743
1744 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, smp_trash->data, NULL);
1745
1746 /* Initialise IV */
1747 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) smp_trash->area))
1748 goto err;
1749
1750 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
1751 if (dec_size < 0)
1752 goto err;
1753 smp_trash->data = dec_size;
1754
1755 /* Initialise key */
1756 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) smp_trash->area, NULL))
1757 goto err;
1758
1759 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
1760 (unsigned char *) smp->data.u.str.area, (int) smp->data.u.str.data))
1761 goto err;
1762
1763 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
1764 if (dec_size < 0)
1765 goto err;
1766 smp_trash_alloc->data = dec_size;
1767 dec_size = smp_trash->data;
1768
1769 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, smp_trash_alloc->data, (void *) smp_trash_alloc->area);
1770 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
1771
1772 if (ret <= 0)
1773 goto err;
1774
1775 smp->data.u.str.data = dec_size + smp_trash->data;
1776 smp->data.u.str.area = smp_trash->area;
1777 smp->data.type = SMP_T_BIN;
1778 smp->flags &= ~SMP_F_CONST;
1779 free_trash_chunk(smp_trash_alloc);
1780 return 1;
1781
1782err:
1783 free_trash_chunk(smp_trash_alloc);
1784 return 0;
1785}
1786#endif /* HA_OPENSSL_VERSION_NUMBER */
1787
Patrick Gansterer8e366512020-04-22 16:47:57 +02001788static int check_crypto_digest(struct arg *args, struct sample_conv *conv,
1789 const char *file, int line, char **err)
1790{
1791 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1792
1793 if (evp)
1794 return 1;
1795
1796 memprintf(err, "algorithm must be a valid OpenSSL message digest name.");
1797 return 0;
1798}
1799
1800static int sample_conv_crypto_digest(const struct arg *args, struct sample *smp, void *private)
1801{
1802 struct buffer *trash = get_trash_chunk();
1803 unsigned char *md = (unsigned char*) trash->area;
1804 unsigned int md_len = trash->size;
1805 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
1806 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1807
1808 if (!ctx)
1809 return 0;
1810
1811 if (!EVP_DigestInit_ex(ctx, evp, NULL) ||
1812 !EVP_DigestUpdate(ctx, smp->data.u.str.area, smp->data.u.str.data) ||
1813 !EVP_DigestFinal_ex(ctx, md, &md_len)) {
1814 EVP_MD_CTX_free(ctx);
1815 return 0;
1816 }
1817
1818 EVP_MD_CTX_free(ctx);
1819
1820 trash->data = md_len;
1821 smp->data.u.str = *trash;
1822 smp->data.type = SMP_T_BIN;
1823 smp->flags &= ~SMP_F_CONST;
1824 return 1;
1825}
1826
1827static int check_crypto_hmac(struct arg *args, struct sample_conv *conv,
1828 const char *file, int line, char **err)
1829{
1830 if (!check_crypto_digest(args, conv, file, line, err))
1831 return 0;
1832
1833 vars_check_arg(&args[1], NULL);
1834 return 1;
1835}
1836
1837static int sample_conv_crypto_hmac(const struct arg *args, struct sample *smp, void *private)
1838{
1839 struct sample key;
1840 struct buffer *trash, *key_trash;
1841 unsigned char *md;
1842 unsigned int md_len;
1843 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1844 int dec_size;
1845
1846 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1847 if (!sample_conv_var2smp_str(&args[1], &key))
1848 return 0;
1849
1850 trash = get_trash_chunk();
1851 key_trash = alloc_trash_chunk();
1852 if (!key_trash)
1853 return 0;
1854
1855 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, key_trash->area, key_trash->size);
1856 if (dec_size < 0)
1857 goto err;
1858
1859 md = (unsigned char*) trash->area;
1860 md_len = trash->size;
1861 if (!HMAC(evp, key_trash->area, dec_size, (const unsigned char*) smp->data.u.str.area, smp->data.u.str.data, md, &md_len))
1862 goto err;
1863
1864 free_trash_chunk(key_trash);
1865
1866 trash->data = md_len;
1867 smp->data.u.str = *trash;
1868 smp->data.type = SMP_T_BIN;
1869 smp->flags &= ~SMP_F_CONST;
1870 return 1;
1871
1872err:
1873 free_trash_chunk(key_trash);
1874 return 0;
1875}
1876
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001877#endif /* USE_OPENSSL */
Tim Duesterhusd4376302019-06-17 12:41:44 +02001878
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001879static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001880{
Willy Tarreau83061a82018-07-13 11:56:34 +02001881 struct buffer *trash = get_trash_chunk();
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001882 unsigned char c;
1883 int ptr = 0;
1884
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001885 trash->data = 0;
1886 while (ptr < smp->data.u.str.data && trash->data <= trash->size - 2) {
1887 c = smp->data.u.str.area[ptr++];
1888 trash->area[trash->data++] = hextab[(c >> 4) & 0xF];
1889 trash->area[trash->data++] = hextab[c & 0xF];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001890 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001891 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001892 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001893 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001894 return 1;
1895}
1896
Dragan Dosen3f957b22017-10-24 09:27:34 +02001897static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
1898{
1899 long long int n = 0;
1900 int i, c;
1901
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001902 for (i = 0; i < smp->data.u.str.data; i++) {
1903 if ((c = hex2i(smp->data.u.str.area[i])) < 0)
Dragan Dosen3f957b22017-10-24 09:27:34 +02001904 return 0;
1905 n = (n << 4) + c;
1906 }
1907
1908 smp->data.u.sint = n;
1909 smp->data.type = SMP_T_SINT;
1910 smp->flags &= ~SMP_F_CONST;
1911 return 1;
1912}
1913
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001914/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001915static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001916{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001917 smp->data.u.sint = hash_djb2(smp->data.u.str.area,
1918 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001919 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001920 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001921 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001922 return 1;
1923}
1924
Willy Tarreau60a2ee72017-12-15 07:13:48 +01001925static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001926{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001927 int i = smp->data.u.str.data;
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001928 smp->data.u.sint = i;
1929 smp->data.type = SMP_T_SINT;
1930 return 1;
1931}
1932
1933
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001934static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001935{
1936 int i;
1937
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001938 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001939 return 0;
1940
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001941 for (i = 0; i < smp->data.u.str.data; i++) {
1942 if ((smp->data.u.str.area[i] >= 'A') && (smp->data.u.str.area[i] <= 'Z'))
1943 smp->data.u.str.area[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001944 }
1945 return 1;
1946}
1947
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001948static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001949{
1950 int i;
1951
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001952 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02001953 return 0;
1954
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001955 for (i = 0; i < smp->data.u.str.data; i++) {
1956 if ((smp->data.u.str.area[i] >= 'a') && (smp->data.u.str.area[i] <= 'z'))
1957 smp->data.u.str.area[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001958 }
1959 return 1;
1960}
1961
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001962/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
1963static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001964{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001965 /* Attempt to convert to IPv4 to apply the correct mask. */
1966 c_ipv62ip(smp);
1967
1968 if (smp->data.type == SMP_T_IPV4) {
1969 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
1970 smp->data.type = SMP_T_IPV4;
1971 }
1972 else if (smp->data.type == SMP_T_IPV6) {
1973 /* IPv6 cannot be converted without an IPv6 mask. */
1974 if (args[1].type != ARGT_IPV6)
1975 return 0;
1976
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +01001977 write_u64(&smp->data.u.ipv6.s6_addr[0],
1978 read_u64(&smp->data.u.ipv6.s6_addr[0]) & read_u64(&args[1].data.ipv6.s6_addr[0]));
1979 write_u64(&smp->data.u.ipv6.s6_addr[8],
1980 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 +01001981 smp->data.type = SMP_T_IPV6;
1982 }
1983
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001984 return 1;
1985}
1986
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001987/* takes an UINT value on input supposed to represent the time since EPOCH,
1988 * adds an optional offset found in args[1] and emits a string representing
1989 * the local time in the format specified in args[1] using strftime().
1990 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001991static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001992{
Willy Tarreau83061a82018-07-13 11:56:34 +02001993 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001994 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001995 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02001996 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001997
1998 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001999 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002000 curr_date += args[1].data.sint;
2001
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002002 tm = localtime(&curr_date);
2003 if (!tm)
2004 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002005 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002006 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2007 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002008 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002009 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002010 return 1;
2011}
2012
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002013/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002014static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002015{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002016 smp->data.u.sint = hash_sdbm(smp->data.u.str.area,
2017 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002018 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002019 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002020 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002021 return 1;
2022}
2023
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002024/* takes an UINT value on input supposed to represent the time since EPOCH,
2025 * adds an optional offset found in args[1] and emits a string representing
2026 * the UTC date in the format specified in args[1] using strftime().
2027 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002028static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002029{
Willy Tarreau83061a82018-07-13 11:56:34 +02002030 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002031 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002032 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002033 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002034
2035 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002036 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002037 curr_date += args[1].data.sint;
2038
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002039 tm = gmtime(&curr_date);
2040 if (!tm)
2041 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002042 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002043 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2044 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002045 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002046 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002047 return 1;
2048}
2049
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002050/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002051static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002052{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002053 smp->data.u.sint = hash_wt6(smp->data.u.str.area,
2054 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002055 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002056 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002057 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002058 return 1;
2059}
2060
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002061/* hashes the binary input into a 32-bit unsigned int using xxh.
2062 * The seed of the hash defaults to 0 but can be changd in argument 1.
2063 */
2064static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
2065{
2066 unsigned int seed;
2067
2068 if (arg_p && arg_p->data.sint)
2069 seed = arg_p->data.sint;
2070 else
2071 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002072 smp->data.u.sint = XXH32(smp->data.u.str.area, smp->data.u.str.data,
2073 seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002074 smp->data.type = SMP_T_SINT;
2075 return 1;
2076}
2077
2078/* hashes the binary input into a 64-bit unsigned int using xxh.
2079 * In fact, the function returns a 64 bit unsigned, but the sample
2080 * storage of haproxy only proposes 64-bits signed, so the value is
2081 * cast as signed. This cast doesn't impact the hash repartition.
2082 * The seed of the hash defaults to 0 but can be changd in argument 1.
2083 */
2084static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
2085{
2086 unsigned long long int seed;
2087
2088 if (arg_p && arg_p->data.sint)
2089 seed = (unsigned long long int)arg_p->data.sint;
2090 else
2091 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002092 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.area,
2093 smp->data.u.str.data, seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002094 smp->data.type = SMP_T_SINT;
2095 return 1;
2096}
2097
Willy Tarreau80599772015-01-20 19:35:24 +01002098/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002099static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002100{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002101 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2102 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002103 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002104 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002105 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002106 return 1;
2107}
2108
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002109/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2110static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2111{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002112 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2113 smp->data.u.str.data);
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002114 if (arg_p && arg_p->data.sint)
2115 smp->data.u.sint = full_hash(smp->data.u.sint);
2116 smp->data.type = SMP_T_SINT;
2117 return 1;
2118}
2119
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002120/* This function escape special json characters. The returned string can be
2121 * safely set between two '"' and used as json string. The json string is
2122 * defined like this:
2123 *
2124 * any Unicode character except '"' or '\' or control character
2125 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2126 *
2127 * The enum input_type contain all the allowed mode for decoding the input
2128 * string.
2129 */
2130enum input_type {
2131 IT_ASCII = 0,
2132 IT_UTF8,
2133 IT_UTF8S,
2134 IT_UTF8P,
2135 IT_UTF8PS,
2136};
2137static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2138 const char *file, int line, char **err)
2139{
Christopher Faulet95917132020-08-05 23:07:07 +02002140 enum input_type type;
2141
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002142 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
Christopher Faulet95917132020-08-05 23:07:07 +02002152 if (strcmp(arg->data.str.area, "") == 0)
2153 type = IT_ASCII;
2154 else if (strcmp(arg->data.str.area, "ascii") == 0)
2155 type = IT_ASCII;
2156 else if (strcmp(arg->data.str.area, "utf8") == 0)
2157 type = IT_UTF8;
2158 else if (strcmp(arg->data.str.area, "utf8s") == 0)
2159 type = IT_UTF8S;
2160 else if (strcmp(arg->data.str.area, "utf8p") == 0)
2161 type = IT_UTF8P;
2162 else if (strcmp(arg->data.str.area, "utf8ps") == 0)
2163 type = IT_UTF8PS;
2164 else {
2165 memprintf(err, "Unexpected input code type. "
2166 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
2167 return 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002168 }
2169
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002170 chunk_destroy(&arg->data.str);
Christopher Faulet95917132020-08-05 23:07:07 +02002171 arg->type = ARGT_SINT;
2172 arg->data.sint = type;
2173 return 1;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002174}
2175
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002176static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002177{
Willy Tarreau83061a82018-07-13 11:56:34 +02002178 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002179 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2180 const char *str;
2181 int len;
2182 enum input_type input_type = IT_ASCII;
2183 unsigned int c;
2184 unsigned int ret;
2185 char *p;
2186
2187 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002188 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002189
2190 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002191 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002192
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002193 p = smp->data.u.str.area;
2194 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002195
2196 if (input_type == IT_ASCII) {
2197 /* Read input as ASCII. */
2198 c = *(unsigned char *)p;
2199 p++;
2200 }
2201 else {
2202 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002203 ret = utf8_next(p,
2204 smp->data.u.str.data - ( p - smp->data.u.str.area),
2205 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002206 p += utf8_return_length(ret);
2207
2208 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2209 return 0;
2210 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2211 continue;
2212 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2213 return 0;
2214 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2215 continue;
2216
2217 /* Check too big values. */
2218 if ((unsigned int)c > 0xffff) {
2219 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2220 return 0;
2221 continue;
2222 }
2223 }
2224
2225 /* Convert character. */
2226 if (c == '"') {
2227 len = 2;
2228 str = "\\\"";
2229 }
2230 else if (c == '\\') {
2231 len = 2;
2232 str = "\\\\";
2233 }
2234 else if (c == '/') {
2235 len = 2;
2236 str = "\\/";
2237 }
2238 else if (c == '\b') {
2239 len = 2;
2240 str = "\\b";
2241 }
2242 else if (c == '\f') {
2243 len = 2;
2244 str = "\\f";
2245 }
2246 else if (c == '\r') {
2247 len = 2;
2248 str = "\\r";
2249 }
2250 else if (c == '\n') {
2251 len = 2;
2252 str = "\\n";
2253 }
2254 else if (c == '\t') {
2255 len = 2;
2256 str = "\\t";
2257 }
Willy Tarreau90807112020-02-25 08:16:33 +01002258 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002259 /* isprint generate a segfault if c is too big. The man says that
2260 * c must have the value of an unsigned char or EOF.
2261 */
2262 len = 6;
2263 _str[0] = '\\';
2264 _str[1] = 'u';
2265 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2266 str = _str;
2267 }
2268 else {
2269 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002270 _str[0] = c;
2271 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002272 }
2273
2274 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002275 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002276 return 0;
2277
2278 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002279 memcpy(temp->area + temp->data, str, len);
2280 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002281 }
2282
2283 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002284 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002285 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002286
2287 return 1;
2288}
2289
Emeric Brun54c4ac82014-11-03 15:32:43 +01002290/* This sample function is designed to extract some bytes from an input buffer.
2291 * First arg is the offset.
2292 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002293static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002294{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002295 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2296 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002297 return 1;
2298 }
2299
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002300 if (smp->data.u.str.size)
2301 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002302 smp->data.u.str.data -= arg_p[0].data.sint;
2303 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002304
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002305 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2306 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002307
2308 return 1;
2309}
2310
Emeric Brunf399b0d2014-11-03 17:07:03 +01002311static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2312 const char *file, int line, char **err)
2313{
2314 struct arg *arg = args;
2315
2316 if (!arg) {
2317 memprintf(err, "Unexpected empty arg list");
2318 return 0;
2319 }
2320
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002321 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002322 memprintf(err, "Unexpected arg type");
2323 return 0;
2324 }
2325
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002326 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002327 memprintf(err, "Unexpected value 0 for index");
2328 return 0;
2329 }
2330
2331 arg++;
2332
2333 if (arg->type != ARGT_STR) {
2334 memprintf(err, "Unexpected arg type");
2335 return 0;
2336 }
2337
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002338 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002339 memprintf(err, "Empty separators list");
2340 return 0;
2341 }
2342
2343 return 1;
2344}
2345
2346/* This sample function is designed to a return selected part of a string (field).
2347 * First arg is the index of the field (start at 1)
2348 * Second arg is a char list of separators (type string)
2349 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002350static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002351{
Marcin Deranek9631a282018-04-16 14:30:46 +02002352 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002353 char *start, *end;
2354 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002355 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002356
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002357 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002358 return 0;
2359
Marcin Deranek9631a282018-04-16 14:30:46 +02002360 if (arg_p[0].data.sint < 0) {
2361 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002362 end = start = smp->data.u.str.area + smp->data.u.str.data;
2363 while (start > smp->data.u.str.area) {
2364 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2365 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002366 if (field == arg_p[0].data.sint) {
2367 if (count == 1)
2368 goto found;
2369 else if (count > 1)
2370 count--;
2371 } else {
2372 end = start-1;
2373 field--;
2374 }
2375 break;
2376 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002377 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002378 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002379 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002380 } else {
2381 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002382 end = start = smp->data.u.str.area;
2383 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2384 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2385 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002386 if (field == arg_p[0].data.sint) {
2387 if (count == 1)
2388 goto found;
2389 else if (count > 1)
2390 count--;
2391 } else {
2392 start = end+1;
2393 field++;
2394 }
2395 break;
2396 }
2397 }
2398 end++;
2399 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002400 }
2401
2402 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002403 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002404 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002405 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002406 }
2407found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002408 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002409 /* If ret string is len 0, no need to
2410 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002411 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002412 return 1;
2413
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002414 smp->data.u.str.area = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002415
2416 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002417 Note: smp->data.u.str.size cannot be set to 0 */
2418 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002419 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002420
2421 return 1;
2422}
2423
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002424/* This sample function is designed to return a word from a string.
2425 * First arg is the index of the word (start at 1)
2426 * Second arg is a char list of words separators (type string)
2427 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002428static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002429{
Marcin Deranek9631a282018-04-16 14:30:46 +02002430 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002431 char *start, *end;
2432 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002433 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002434
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002435 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002436 return 0;
2437
2438 word = 0;
2439 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002440 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002441 end = start = smp->data.u.str.area + smp->data.u.str.data;
2442 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002443 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002444 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2445 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002446 issep = 1;
2447 break;
2448 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002449 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002450 if (!inword) {
2451 if (!issep) {
2452 if (word != arg_p[0].data.sint) {
2453 word--;
2454 end = start;
2455 }
2456 inword = 1;
2457 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002458 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002459 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002460 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002461 if (count == 1)
2462 goto found;
2463 else if (count > 1)
2464 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002465 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002466 inword = 0;
2467 }
2468 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002469 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002470 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002471 end = start = smp->data.u.str.area;
2472 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002473 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002474 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2475 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002476 issep = 1;
2477 break;
2478 }
2479 }
2480 if (!inword) {
2481 if (!issep) {
2482 if (word != arg_p[0].data.sint) {
2483 word++;
2484 start = end;
2485 }
2486 inword = 1;
2487 }
2488 }
2489 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002490 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002491 if (count == 1)
2492 goto found;
2493 else if (count > 1)
2494 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002495 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002496 inword = 0;
2497 }
2498 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002499 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002500 }
2501
2502 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002503 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002504 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002505 return 1;
2506 }
2507found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002508 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002509 /* If ret string is len 0, no need to
2510 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002511 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002512 return 1;
2513
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002514 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002515
2516 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002517 Note: smp->data.u.str.size cannot be set to 0 */
2518 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002519 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002520
2521 return 1;
2522}
2523
Willy Tarreau7eda8492015-01-20 19:47:06 +01002524static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2525 const char *file, int line, char **err)
2526{
2527 struct arg *arg = args;
2528 char *p;
2529 int len;
2530
2531 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2532 arg[0].type_flags = 0;
2533
2534 if (arg[2].type != ARGT_STR)
2535 return 1;
2536
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002537 p = arg[2].data.str.area;
2538 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002539 while (len) {
2540 if (*p == 'i') {
2541 arg[0].type_flags |= ARGF_REG_ICASE;
2542 }
2543 else if (*p == 'g') {
2544 arg[0].type_flags |= ARGF_REG_GLOB;
2545 }
2546 else {
2547 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2548 return 0;
2549 }
2550 p++;
2551 len--;
2552 }
2553 return 1;
2554}
2555
2556/* This sample function is designed to do the equivalent of s/match/replace/ on
2557 * the input string. It applies a regex and restarts from the last matched
2558 * location until nothing matches anymore. First arg is the regex to apply to
2559 * the input string, second arg is the replacement expression.
2560 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002561static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002562{
2563 char *start, *end;
2564 struct my_regex *reg = arg_p[0].data.reg;
2565 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002566 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002567 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002568 int flag, max;
2569 int found;
2570
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002571 start = smp->data.u.str.area;
2572 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002573
2574 flag = 0;
2575 while (1) {
2576 /* check for last round which is used to copy remaining parts
2577 * when not running in global replacement mode.
2578 */
2579 found = 0;
2580 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2581 /* Note: we can have start == end on empty strings or at the end */
2582 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2583 }
2584
2585 if (!found)
2586 pmatch[0].rm_so = end - start;
2587
2588 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002589 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002590 if (max && pmatch[0].rm_so > 0) {
2591 if (max > pmatch[0].rm_so)
2592 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002593 memcpy(trash->area + trash->data, start, max);
2594 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002595 }
2596
2597 if (!found)
2598 break;
2599
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002600 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002601 if (!output)
2602 break;
2603
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002604 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2605
Willy Tarreau7eda8492015-01-20 19:47:06 +01002606 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002607 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002608 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002609 if (max > output->data)
2610 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002611 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002612 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002613 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002614 }
2615
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002616 free_trash_chunk(output);
2617
Willy Tarreau7eda8492015-01-20 19:47:06 +01002618 /* stop here if we're done with this string */
2619 if (start >= end)
2620 break;
2621
2622 /* We have a special case for matches of length 0 (eg: "x*y*").
2623 * These ones are considered to match in front of a character,
2624 * so we have to copy that character and skip to the next one.
2625 */
2626 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002627 if (trash->data < trash->size)
2628 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002629 pmatch[0].rm_eo++;
2630 }
2631
2632 start += pmatch[0].rm_eo;
2633 flag |= REG_NOTBOL;
2634 }
2635
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002636 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002637 return 1;
2638}
2639
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002640/* This function check an operator entry. It expects a string.
2641 * The string can be an integer or a variable name.
2642 */
2643static int check_operator(struct arg *args, struct sample_conv *conv,
2644 const char *file, int line, char **err)
2645{
2646 const char *str;
2647 const char *end;
Christopher Faulet95917132020-08-05 23:07:07 +02002648 long long int i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002649
2650 /* Try to decode a variable. */
2651 if (vars_check_arg(&args[0], NULL))
2652 return 1;
2653
2654 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002655 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002656 end = str + strlen(str);
Christopher Faulet95917132020-08-05 23:07:07 +02002657 i = read_int64(&str, end);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002658 if (*str != '\0') {
2659 memprintf(err, "expects an integer or a variable name");
2660 return 0;
2661 }
Christopher Faulet95917132020-08-05 23:07:07 +02002662
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002663 chunk_destroy(&args[0].data.str);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002664 args[0].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02002665 args[0].data.sint = i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002666 return 1;
2667}
2668
Willy Tarreau6204cd92016-03-10 16:33:04 +01002669/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002670 * If the arg contain an integer, the integer is returned in the
2671 * sample. If the arg contains a variable descriptor, it returns the
2672 * variable value.
2673 *
2674 * This function returns 0 if an error occurs, otherwise it returns 1.
2675 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002676static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002677{
2678 switch (arg->type) {
2679 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002680 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002681 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002682 return 1;
2683 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002684 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002685 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002686 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002687 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002688 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002689 return 0;
2690 return 1;
2691 default:
2692 return 0;
2693 }
2694}
2695
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002696/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002697 * result.
2698 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002699static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002700{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002701 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002702 return 1;
2703}
2704
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002705/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002706 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002707 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002708static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002709{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002710 struct sample tmp;
2711
Willy Tarreau7560dd42016-03-10 16:28:58 +01002712 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002713 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002714 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002715 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002716 return 1;
2717}
2718
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002719/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002720 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002721 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002722static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002723{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002724 struct sample tmp;
2725
Willy Tarreau7560dd42016-03-10 16:28:58 +01002726 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002727 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002728 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002729 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002730 return 1;
2731}
2732
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002733/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002734 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002735 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002736static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002737{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002738 struct sample tmp;
2739
Willy Tarreau7560dd42016-03-10 16:28:58 +01002740 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002741 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002742 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002743 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002744 return 1;
2745}
2746
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002747static inline long long int arith_add(long long int a, long long int b)
2748{
2749 /* Prevent overflow and makes capped calculus.
2750 * We must ensure that the check calculus doesn't
2751 * exceed the signed 64 bits limits.
2752 *
2753 * +----------+----------+
2754 * | a<0 | a>=0 |
2755 * +------+----------+----------+
2756 * | b<0 | MIN-a>b | no check |
2757 * +------+----------+----------+
2758 * | b>=0 | no check | MAX-a<b |
2759 * +------+----------+----------+
2760 */
2761 if ((a ^ b) >= 0) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002762 /* signs are different. */
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002763 if (a < 0) {
2764 if (LLONG_MIN - a > b)
2765 return LLONG_MIN;
2766 }
2767 if (LLONG_MAX - a < b)
2768 return LLONG_MAX;
2769 }
2770 return a + b;
2771}
2772
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002773/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002774 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002775 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002776static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002777{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002778 struct sample tmp;
2779
Willy Tarreau7560dd42016-03-10 16:28:58 +01002780 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002781 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002782 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002783 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002784 return 1;
2785}
2786
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002787/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002788 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002789 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002790static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002791 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002792{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002793 struct sample tmp;
2794
Willy Tarreau7560dd42016-03-10 16:28:58 +01002795 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002796 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002797 return 0;
2798
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002799 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2800 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2801 * of -LLONG_MIN and correct the result.
2802 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002803 if (tmp.data.u.sint == LLONG_MIN) {
2804 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2805 if (smp->data.u.sint < LLONG_MAX)
2806 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002807 return 1;
2808 }
2809
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002810 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002811 * the second operand.
2812 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002813 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002814 return 1;
2815}
2816
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002817/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002818 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002819 * If the result makes an overflow, then the largest possible quantity is
2820 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002821 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002822static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002823 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002824{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002825 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002826 long long int c;
2827
Willy Tarreau7560dd42016-03-10 16:28:58 +01002828 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002829 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002830 return 0;
2831
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002832 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002833 if (!smp->data.u.sint || !tmp.data.u.sint) {
2834 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002835 return 1;
2836 }
2837
2838 /* The multiply between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002839 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002840 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002841 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2842 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002843 return 1;
2844 }
2845
2846 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002847 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002848
2849 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002850 if (smp->data.u.sint != c / tmp.data.u.sint) {
2851 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2852 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002853 return 1;
2854 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002855 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002856 return 1;
2857 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002858 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002859 return 1;
2860}
2861
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002862/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002863 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002864 * If arg_p makes the result overflow, then the largest possible quantity is
2865 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002866 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002867static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002868 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002869{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002870 struct sample tmp;
2871
Willy Tarreau7560dd42016-03-10 16:28:58 +01002872 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002873 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002874 return 0;
2875
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002876 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002877 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002878 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002879 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002880 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2881 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002882 return 1;
2883 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002884 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002885 return 1;
2886 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002887 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002888 return 1;
2889}
2890
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002891/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002892 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002893 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002894 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002895static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002896 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002897{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002898 struct sample tmp;
2899
Willy Tarreau7560dd42016-03-10 16:28:58 +01002900 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002901 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002902 return 0;
2903
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002904 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002905 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002906 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002907 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002908 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2909 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002910 return 1;
2911 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002912 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002913 return 1;
2914 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002915 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002916 return 1;
2917}
2918
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002919/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002920 * result.
2921 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002922static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002923 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002924{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002925 if (smp->data.u.sint == LLONG_MIN)
2926 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002927 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002928 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002929 return 1;
2930}
2931
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002932/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002933 * false. The output is a BOOL.
2934 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002935static int sample_conv_arith_bool(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 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002939 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002940 return 1;
2941}
2942
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002943/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002944 * truee. The output is a BOOL.
2945 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002946static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002947 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002948{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002949 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002950 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002951 return 1;
2952}
2953
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002954/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002955 * The output is a BOOL.
2956 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002957static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002958 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002959{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002960 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002961 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002962 return 1;
2963}
2964
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002965/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002966 * The output is a BOOL.
2967 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002968static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002969 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002970{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002971 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002972 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002973 return 1;
2974}
2975
Willy Tarreau280f42b2018-02-19 15:34:12 +01002976/* appends an optional const string, an optional variable contents and another
2977 * optional const string to an existing string.
2978 */
2979static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
2980{
Willy Tarreau83061a82018-07-13 11:56:34 +02002981 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002982 struct sample tmp;
2983 int max;
2984
2985 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002986 trash->data = smp->data.u.str.data;
2987 if (trash->data > trash->size - 1)
2988 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002989
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002990 memcpy(trash->area, smp->data.u.str.area, trash->data);
2991 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002992
2993 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002994 max = arg_p[0].data.str.data;
2995 if (max > trash->size - 1 - trash->data)
2996 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002997
2998 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002999 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3000 trash->data += max;
3001 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003002 }
3003
3004 /* append second string (variable) if it's found and we can turn it
3005 * into a string.
3006 */
3007 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3008 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3009 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3010 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3011
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003012 max = tmp.data.u.str.data;
3013 if (max > trash->size - 1 - trash->data)
3014 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003015
3016 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003017 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3018 max);
3019 trash->data += max;
3020 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003021 }
3022 }
3023
3024 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003025 max = arg_p[2].data.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, arg_p[2].data.str.area, max);
3031 trash->data += max;
3032 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003033 }
3034
3035 smp->data.u.str = *trash;
3036 smp->data.type = SMP_T_STR;
3037 return 1;
3038}
3039
3040/* This function checks the "concat" converter's arguments and extracts the
3041 * variable name and its scope.
3042 */
3043static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3044 const char *file, int line, char **err)
3045{
3046 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003047 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3048 memprintf(err, "failed to register variable name '%s'",
3049 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003050 return 0;
3051 }
3052 return 1;
3053}
3054
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003055/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003056 * is compatible with strcmp(3)'s return value.
3057 */
3058static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3059{
3060 struct sample tmp;
3061 int max, result;
3062
3063 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3064 if (arg_p[0].type != ARGT_VAR)
3065 return 0;
3066 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3067 return 0;
3068 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3069 return 0;
3070
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003071 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3072 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003073 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003074 if (smp->data.u.str.data != tmp.data.u.str.data) {
3075 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003076 result = -1;
3077 }
3078 else {
3079 result = 1;
3080 }
3081 }
3082 }
3083
3084 smp->data.u.sint = result;
3085 smp->data.type = SMP_T_SINT;
3086 return 1;
3087}
3088
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003089#ifdef USE_OPENSSL
3090/* Compares bytestring with a variable containing a bytestring. Return value
3091 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3092 *
3093 * Comparison will be performed in constant time if both bytestrings are of
3094 * the same length. If the lengths differ execution time will not be constant.
3095 */
3096static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3097{
3098 struct sample tmp;
3099 int result;
3100
3101 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3102 if (arg_p[0].type != ARGT_VAR)
3103 return 0;
3104 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3105 return 0;
3106 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3107 return 0;
3108
3109 if (smp->data.u.str.data != tmp.data.u.str.data) {
3110 smp->data.u.sint = 0;
3111 smp->data.type = SMP_T_BOOL;
3112 return 1;
3113 }
3114
3115 /* The following comparison is performed in constant time. */
3116 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3117
3118 smp->data.u.sint = result == 0;
3119 smp->data.type = SMP_T_BOOL;
3120 return 1;
3121}
3122#endif
3123
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003124#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3125#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3126#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3127
3128/*
3129 * Extract the field value of an input binary sample. Takes a mandatory argument:
3130 * the protocol buffers field identifier (dotted notation) internally represented
3131 * as an array of unsigned integers and its size.
3132 * Return 1 if the field was found, 0 if not.
3133 */
3134static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3135{
3136 unsigned char *pos;
3137 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003138
3139 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003140 grpc_left = smp->data.u.str.data;
3141
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003142 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003143 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003144
3145 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3146
3147 pos += GRPC_MSG_HEADER_SZ;
3148 grpc_left -= GRPC_MSG_HEADER_SZ;
3149
3150 if (grpc_left < left)
3151 return 0;
3152
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003153 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3154 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003155
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003156 grpc_left -= grpc_msg_len;
3157 }
3158
3159 return 0;
3160}
3161
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003162static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3163{
3164 unsigned char *pos;
3165 size_t left;
3166
3167 pos = (unsigned char *)smp->data.u.str.area;
3168 left = smp->data.u.str.data;
3169
3170 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3171}
3172
3173static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3174 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003175{
3176 if (!args[1].type) {
3177 args[1].type = ARGT_SINT;
3178 args[1].data.sint = PBUF_T_BINARY;
3179 }
3180 else {
3181 int pbuf_type;
3182
3183 pbuf_type = protobuf_type(args[1].data.str.area);
3184 if (pbuf_type == -1) {
3185 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3186 return 0;
3187 }
3188
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003189 chunk_destroy(&args[1].data.str);
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003190 args[1].type = ARGT_SINT;
3191 args[1].data.sint = pbuf_type;
3192 }
3193
3194 return 1;
3195}
3196
Tim Duesterhusca097c12018-04-27 21:18:45 +02003197/* This function checks the "strcmp" converter's arguments and extracts the
3198 * variable name and its scope.
3199 */
3200static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3201 const char *file, int line, char **err)
3202{
3203 /* Try to decode a variable. */
3204 if (vars_check_arg(&args[0], NULL))
3205 return 1;
3206
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003207 memprintf(err, "failed to register variable name '%s'",
3208 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003209 return 0;
3210}
3211
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003212#ifdef USE_OPENSSL
3213/* This function checks the "secure_memcmp" converter's arguments and extracts the
3214 * variable name and its scope.
3215 */
3216static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3217 const char *file, int line, char **err)
3218{
3219 /* Try to decode a variable. */
3220 if (vars_check_arg(&args[0], NULL))
3221 return 1;
3222
3223 memprintf(err, "failed to register variable name '%s'",
3224 args[0].data.str.area);
3225 return 0;
3226}
3227#endif
3228
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003229/**/
3230static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3231{
3232 struct buffer *tmp;
3233 uint32_t n;
3234
3235 n = htonl((uint32_t)smp->data.u.sint);
3236 tmp = get_trash_chunk();
3237
3238 memcpy(b_head(tmp), &n, 4);
3239 b_add(tmp, 4);
3240
3241 smp->data.u.str = *tmp;
3242 smp->data.type = SMP_T_BIN;
3243 return 1;
3244}
3245
Christopher Fauletea159d62020-04-01 16:21:44 +02003246/**/
3247static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3248{
3249 char *p;
3250 size_t l;
3251
3252 p = smp->data.u.str.area;
3253 for (l = 0; l < smp->data.u.str.data; l++) {
3254 if (*(p+l) == '\r' || *(p+l) == '\n')
3255 break;
3256 }
3257 smp->data.u.str.data = l;
3258 return 1;
3259}
3260
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003261/**/
3262static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3263{
3264 char *delimiters, *p;
3265 size_t dlen, l;
3266
3267 delimiters = arg_p[0].data.str.area;
3268 dlen = arg_p[0].data.str.data;
3269
3270 l = smp->data.u.str.data;
3271 p = smp->data.u.str.area;
3272 while (l && memchr(delimiters, *p, dlen) != NULL) {
3273 p++;
3274 l--;
3275 }
3276
3277 smp->data.u.str.area = p;
3278 smp->data.u.str.data = l;
3279 return 1;
3280}
3281
Christopher Faulet568415a2020-04-01 17:24:47 +02003282/**/
3283static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3284{
3285 char *delimiters, *p;
3286 size_t dlen, l;
3287
3288 delimiters = arg_p[0].data.str.area;
3289 dlen = arg_p[0].data.str.data;
3290
3291 l = smp->data.u.str.data;
3292 p = smp->data.u.str.area + l - 1;
3293 while (l && memchr(delimiters, *p, dlen) != NULL) {
3294 p--;
3295 l--;
3296 }
3297
3298 smp->data.u.str.data = l;
3299 return 1;
3300}
3301
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003302/************************************************************************/
3303/* All supported sample fetch functions must be declared here */
3304/************************************************************************/
3305
3306/* force TRUE to be returned at the fetch level */
3307static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003308smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003309{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003310 if (!smp_make_rw(smp))
3311 return 0;
3312
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003313 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003314 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003315 return 1;
3316}
3317
3318/* force FALSE to be returned at the fetch level */
3319static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003320smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003321{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003322 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003323 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003324 return 1;
3325}
3326
3327/* retrieve environment variable $1 as a string */
3328static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003329smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003330{
3331 char *env;
3332
3333 if (!args || args[0].type != ARGT_STR)
3334 return 0;
3335
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003336 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003337 if (!env)
3338 return 0;
3339
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003340 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003341 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003342 smp->data.u.str.area = env;
3343 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003344 return 1;
3345}
3346
Damien Claisseae6f1252019-10-30 15:57:28 +00003347/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3348 * optional string representing the unit of the result: "s" for seconds, "ms" for
3349 * milliseconds and "us" for microseconds.
3350 * Returns 0 on error and non-zero if OK.
3351 */
3352int smp_check_date_unit(struct arg *args, char **err)
3353{
3354 if (args[1].type == ARGT_STR) {
Christopher Faulet95917132020-08-05 23:07:07 +02003355 long long int unit;
3356
Damien Claisseae6f1252019-10-30 15:57:28 +00003357 if (strcmp(args[1].data.str.area, "s") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003358 unit = TIME_UNIT_S;
Damien Claisseae6f1252019-10-30 15:57:28 +00003359 }
3360 else if (strcmp(args[1].data.str.area, "ms") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003361 unit = TIME_UNIT_MS;
Damien Claisseae6f1252019-10-30 15:57:28 +00003362 }
3363 else if (strcmp(args[1].data.str.area, "us") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003364 unit = TIME_UNIT_US;
Damien Claisseae6f1252019-10-30 15:57:28 +00003365 }
3366 else {
3367 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3368 args[1].data.str.area);
3369 return 0;
3370 }
Christopher Faulet95917132020-08-05 23:07:07 +02003371
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003372 chunk_destroy(&args[1].data.str);
Damien Claisseae6f1252019-10-30 15:57:28 +00003373 args[1].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02003374 args[1].data.sint = unit;
Damien Claisseae6f1252019-10-30 15:57:28 +00003375 }
3376 else if (args[1].type != ARGT_STOP) {
3377 memprintf(err, "Unexpected arg type");
3378 return 0;
3379 }
3380
3381 return 1;
3382}
3383
3384/* retrieve the current local date in epoch time, converts it to milliseconds
3385 * or microseconds if asked to in optional args[1] unit param, and applies an
3386 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003387 */
3388static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003389smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003390{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003391 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003392
Damien Claisseae6f1252019-10-30 15:57:28 +00003393 /* report in milliseconds */
3394 if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
3395 smp->data.u.sint *= 1000;
3396 smp->data.u.sint += date.tv_usec / 1000;
3397 }
3398 /* report in microseconds */
3399 else if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
3400 smp->data.u.sint *= 1000000;
3401 smp->data.u.sint += date.tv_usec;
3402 }
3403
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003404 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003405 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003406 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003407
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003408 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003409 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3410 return 1;
3411}
3412
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003413/* retrieve the current microsecond part of the date */
3414static int
3415smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3416{
3417 smp->data.u.sint = date.tv_usec;
3418 smp->data.type = SMP_T_SINT;
3419 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3420 return 1;
3421}
3422
3423
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003424/* returns the hostname */
3425static int
3426smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3427{
3428 smp->data.type = SMP_T_STR;
3429 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003430 smp->data.u.str.area = hostname;
3431 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003432 return 1;
3433}
3434
Willy Tarreau0f30d262014-11-24 16:02:05 +01003435/* returns the number of processes */
3436static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003437smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003438{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003439 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003440 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003441 return 1;
3442}
3443
3444/* returns the number of the current process (between 1 and nbproc */
3445static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003446smp_fetch_proc(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 = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003450 return 1;
3451}
3452
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003453/* returns the number of the current thread (between 1 and nbthread */
3454static int
3455smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3456{
3457 smp->data.type = SMP_T_SINT;
3458 smp->data.u.sint = tid;
3459 return 1;
3460}
3461
Willy Tarreau84310e22014-02-14 11:59:04 +01003462/* generate a random 32-bit integer for whatever purpose, with an optional
3463 * range specified in argument.
3464 */
3465static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003466smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003467{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003468 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003469
3470 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003471 if (args && args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003472 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003473
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003474 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003475 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3476 return 1;
3477}
3478
Willy Tarreau0f30d262014-11-24 16:02:05 +01003479/* returns true if the current process is stopping */
3480static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003481smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003482{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003483 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003484 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003485 return 1;
3486}
3487
Willy Tarreau70fe9442018-11-22 16:07:39 +01003488/* returns the number of calls of the current stream's process_stream() */
3489static int
3490smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
3491{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003492 if (!smp->strm)
3493 return 0;
3494
Willy Tarreau70fe9442018-11-22 16:07:39 +01003495 smp->data.type = SMP_T_SINT;
3496 smp->data.u.sint = smp->strm->task->calls;
3497 return 1;
3498}
3499
3500/* returns the average number of nanoseconds spent processing the stream per call */
3501static int
3502smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3503{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003504 if (!smp->strm)
3505 return 0;
3506
Willy Tarreau70fe9442018-11-22 16:07:39 +01003507 smp->data.type = SMP_T_SINT;
3508 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
3509 return 1;
3510}
3511
3512/* returns the total number of nanoseconds spent processing the stream */
3513static int
3514smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3515{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003516 if (!smp->strm)
3517 return 0;
3518
Willy Tarreau70fe9442018-11-22 16:07:39 +01003519 smp->data.type = SMP_T_SINT;
3520 smp->data.u.sint = smp->strm->task->cpu_time;
3521 return 1;
3522}
3523
3524/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
3525static int
3526smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3527{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003528 if (!smp->strm)
3529 return 0;
3530
Willy Tarreau70fe9442018-11-22 16:07:39 +01003531 smp->data.type = SMP_T_SINT;
3532 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
3533 return 1;
3534}
3535
3536/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
3537static int
3538smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3539{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003540 if (!smp->strm)
3541 return 0;
3542
Willy Tarreau70fe9442018-11-22 16:07:39 +01003543 smp->data.type = SMP_T_SINT;
3544 smp->data.u.sint = smp->strm->task->lat_time;
3545 return 1;
3546}
3547
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003548static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
3549{
3550 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003551 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003552 smp->data.u.str.area = args[0].data.str.area;
3553 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003554 return 1;
3555}
3556
3557static int smp_check_const_bool(struct arg *args, char **err)
3558{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003559 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
3560 strcasecmp(args[0].data.str.area, "1") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003561 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003562 args[0].type = ARGT_SINT;
3563 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003564 return 1;
3565 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003566 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
3567 strcasecmp(args[0].data.str.area, "0") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003568 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003569 args[0].type = ARGT_SINT;
3570 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003571 return 1;
3572 }
3573 memprintf(err, "Expects 'true', 'false', '0' or '1'");
3574 return 0;
3575}
3576
3577static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
3578{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003579 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003580 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003581 return 1;
3582}
3583
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003584static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003585{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003586 smp->data.type = SMP_T_SINT;
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
3591static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
3592{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003593 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003594 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003595 return 1;
3596}
3597
3598static int smp_fetch_const_ipv6(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_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003601 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003602 return 1;
3603}
3604
3605static int smp_check_const_bin(struct arg *args, char **err)
3606{
David Carlier64a16ab2016-04-08 10:37:02 +01003607 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003608 int binstrlen;
3609
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003610 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003611 return 0;
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003612 chunk_destroy(&args[0].data.str);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003613 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003614 args[0].data.str.area = binstr;
3615 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003616 return 1;
3617}
3618
3619static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
3620{
3621 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003622 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003623 smp->data.u.str.area = args[0].data.str.area;
3624 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003625 return 1;
3626}
3627
3628static int smp_check_const_meth(struct arg *args, char **err)
3629{
3630 enum http_meth_t meth;
3631 int i;
3632
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003633 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003634 if (meth != HTTP_METH_OTHER) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003635 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003636 args[0].type = ARGT_SINT;
3637 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003638 } else {
Ilya Shipitsin6b79f382020-07-23 00:32:55 +05003639 /* Check method avalaibility. A method is a token defined as :
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003640 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
3641 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
3642 * token = 1*tchar
3643 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003644 for (i = 0; i < args[0].data.str.data; i++) {
3645 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003646 memprintf(err, "expects valid method.");
3647 return 0;
3648 }
3649 }
3650 }
3651 return 1;
3652}
3653
3654static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
3655{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003656 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003657 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003658 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003659 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003660 smp->data.u.meth.str.area = "";
3661 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003662 } else {
3663 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003664 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003665 smp->data.u.meth.str.area = args[0].data.str.area;
3666 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003667 }
3668 return 1;
3669}
3670
Luca Schimweg8a694b82019-09-10 15:42:52 +02003671// This function checks the "uuid" sample's arguments.
3672// Function won't get called when no parameter is specified (maybe a bug?)
3673static int smp_check_uuid(struct arg *args, char **err)
3674{
3675 if (!args[0].type) {
3676 args[0].type = ARGT_SINT;
3677 args[0].data.sint = 4;
3678 }
3679 else if (args[0].data.sint != 4) {
3680 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
3681 return 0;
3682 }
3683
3684 return 1;
3685}
3686
3687// Generate a RFC4122 UUID (default is v4 = fully random)
3688static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
3689{
3690 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01003691 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02003692 smp->data.type = SMP_T_STR;
3693 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3694 smp->data.u.str = trash;
3695 return 1;
3696 }
3697
3698 // more implementations of other uuid formats possible here
3699 return 0;
3700}
3701
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003702/* Note: must not be declared <const> as its list will be overwritten.
3703 * Note: fetches that may return multiple types must be declared as the lowest
3704 * common denominator, the type that can be casted into all other ones. For
3705 * instance IPv4/IPv6 must be declared IPv4.
3706 */
3707static struct sample_fetch_kw_list smp_kws = {ILH, {
3708 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
3709 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003710 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Damien Claisseae6f1252019-10-30 15:57:28 +00003711 { "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 +01003712 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003713 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003714 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3715 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003716 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003717 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01003718 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003719 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Luca Schimweg8a694b82019-09-10 15:42:52 +02003720 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003721
3722 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3723 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3724 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3725 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3726 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003727
3728 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
3729 { "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 +02003730 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003731 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
3732 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
3733 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
3734 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
3735
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003736 { /* END */ },
3737}};
3738
Willy Tarreau0108d902018-11-25 19:14:37 +01003739INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3740
Emeric Brun107ca302010-01-04 16:16:05 +01003741/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003742static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau0851fd52019-12-17 10:07:25 +01003743 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
Holger Just1bfc24b2017-05-06 00:56:53 +02003744 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02003745 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02003746 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
3747 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01003748 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01003749 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02003750 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01003751 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003752 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
3753 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003754 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01003755 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003756 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3757 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3758 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01003759 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3760 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003761 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003762 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
Marcin Deranek9631a282018-04-16 14:30:46 +02003763 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
3764 { "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 +01003765 { "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 +02003766 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003767#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01003768 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02003769#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
3770 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
3771#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02003772 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
3773 { "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 +02003774#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01003775 { "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 +02003776 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003777#ifdef USE_OPENSSL
3778 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
3779#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003780
3781 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003782 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
3783 { "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 +01003784
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003785 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3786 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3787 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3788 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
3789 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3790 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3791 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3792 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3793 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3794 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3795 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3796 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3797 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3798 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01003799
Christopher Fauletea159d62020-04-01 16:21:44 +02003800 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
3801 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003802 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02003803 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02003804 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01003805}};
3806
Willy Tarreau0108d902018-11-25 19:14:37 +01003807INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);