blob: 510d6b5045e8defe59da98efbacea2ab69833864 [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
Alex51c8ad42021-04-15 16:45:15 +020019#include <import/mjson.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020020#include <import/sha1.h>
21#include <import/xxhash.h>
Willy Tarreau7e2c6472012-10-29 20:44:36 +010022
Willy Tarreaub2551052020-06-09 09:07:15 +020023#include <haproxy/api.h>
24#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020025#include <haproxy/auth.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020026#include <haproxy/base64.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020027#include <haproxy/buf.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020028#include <haproxy/chunk.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020029#include <haproxy/errors.h>
Baptiste Assmanne138dda2020-10-22 15:39:03 +020030#include <haproxy/fix.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020031#include <haproxy/global.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020032#include <haproxy/hash.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020033#include <haproxy/http.h>
Baptiste Assmanne138dda2020-10-22 15:39:03 +020034#include <haproxy/istbuf.h>
Baptiste Assmanne279ca62020-10-27 18:10:06 +010035#include <haproxy/mqtt.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020036#include <haproxy/net_helper.h>
Willy Tarreaub23e5952020-06-04 16:06:59 +020037#include <haproxy/protobuf.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020038#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020039#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020040#include <haproxy/sample.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020041#include <haproxy/sink.h>
42#include <haproxy/stick_table.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020043#include <haproxy/tools.h>
Willy Tarreau8c42b8a2020-06-04 19:27:34 +020044#include <haproxy/uri_auth-t.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020045#include <haproxy/vars.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010046
Willy Tarreau1cf8f082014-02-07 12:14:54 +010047/* sample type names */
48const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020049 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010050 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010051 [SMP_T_SINT] = "sint",
52 [SMP_T_ADDR] = "addr",
53 [SMP_T_IPV4] = "ipv4",
54 [SMP_T_IPV6] = "ipv6",
55 [SMP_T_STR] = "str",
56 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020057 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010058};
59
Willy Tarreau12785782012-04-27 21:37:17 +020060/* static sample used in sample_process() when <p> is NULL */
Emeric Brune5c918b2017-06-14 14:15:36 +020061static THREAD_LOCAL struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010062
Willy Tarreau12785782012-04-27 21:37:17 +020063/* list head of all known sample fetch keywords */
64static struct sample_fetch_kw_list sample_fetches = {
65 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010066};
67
Willy Tarreau12785782012-04-27 21:37:17 +020068/* list head of all known sample format conversion keywords */
69static struct sample_conv_kw_list sample_convs = {
70 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010071};
72
Willy Tarreau80aca902013-01-07 15:42:20 +010073const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
Willy Tarreaube2159b2021-03-26 11:56:11 +010074 [SMP_SRC_CONST] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
75 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
76 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
77 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
78 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
79 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +010080 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL_CFG_PARSER |
81 SMP_VAL_CLI_PARSER ),
Willy Tarreaube2159b2021-03-26 11:56:11 +010082
Willy Tarreau80aca902013-01-07 15:42:20 +010083 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
84 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
85 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
86 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
87 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
88 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +010089 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
90 SMP_VAL_CLI_PARSER ),
Willy Tarreau80aca902013-01-07 15:42:20 +010091
92 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
93 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
94 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
95 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
96 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
97 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +010098 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
99 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100100
101 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
102 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
103 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
104 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
105 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
106 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100107 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
108 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100109
110 [SMP_SRC_L4CLI] = (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 |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100116 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
117 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100118
119 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
120 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
121 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
122 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
123 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
124 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100125 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
126 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100127
128 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
129 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
130 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
131 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
132 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
133 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100134 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
135 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100136
137 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
138 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
139 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
140 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
141 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
142 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100143 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
144 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100145
146 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
147 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
148 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
149 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
150 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
151 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100152 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
153 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100154
155 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
156 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
157 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
158 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
159 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
160 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100161 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
162 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100163
164 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
165 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
166 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
167 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
168 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
169 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100170 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
171 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100172
173 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
174 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
175 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
176 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
177 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
178 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100179 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
180 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100181
182 [SMP_SRC_SERVR] = (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_BE_SRV_CON | 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 |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100188 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
189 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100190
191 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
192 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
193 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
194 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
195 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
196 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100197 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
198 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100199
200 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
201 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
202 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
203 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
204 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
205 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100206 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
207 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100208
209 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
210 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
211 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
212 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
213 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
214 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100215 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
216 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100217
218 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
220 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
221 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
222 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
223 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100224 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
225 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100226
227 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
228 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
229 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
230 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
231 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
232 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100233 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
234 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100235
236 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
237 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
238 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
239 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
240 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
241 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100242 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL | SMP_VAL___________ |
243 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100244
245 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
246 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
247 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
248 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
249 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
250 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100251 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
252 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100253
254 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
255 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
256 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
257 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
258 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
259 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100260 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
261 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100262
263 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
264 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
265 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
266 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
267 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
268 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100269 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
270 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100271
272 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
273 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
274 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
275 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
276 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
277 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Willy Tarreaudb5e0db2021-03-26 15:29:35 +0100278 SMP_VAL_FE_LOG_END | SMP_VAL___________ | SMP_VAL___________ |
279 SMP_VAL___________ ),
Willy Tarreau80aca902013-01-07 15:42:20 +0100280};
281
282static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
283 [SMP_SRC_INTRN] = "internal state",
284 [SMP_SRC_LISTN] = "listener",
285 [SMP_SRC_FTEND] = "frontend",
286 [SMP_SRC_L4CLI] = "client address",
287 [SMP_SRC_L5CLI] = "client-side connection",
288 [SMP_SRC_TRACK] = "track counters",
289 [SMP_SRC_L6REQ] = "request buffer",
290 [SMP_SRC_HRQHV] = "HTTP request headers",
291 [SMP_SRC_HRQHP] = "HTTP request",
292 [SMP_SRC_HRQBO] = "HTTP request body",
293 [SMP_SRC_BKEND] = "backend",
294 [SMP_SRC_SERVR] = "server",
295 [SMP_SRC_L4SRV] = "server address",
296 [SMP_SRC_L5SRV] = "server-side connection",
297 [SMP_SRC_L6RES] = "response buffer",
298 [SMP_SRC_HRSHV] = "HTTP response headers",
299 [SMP_SRC_HRSHP] = "HTTP response",
300 [SMP_SRC_HRSBO] = "HTTP response body",
301 [SMP_SRC_RQFIN] = "request buffer statistics",
302 [SMP_SRC_RSFIN] = "response buffer statistics",
303 [SMP_SRC_TXFIN] = "transaction statistics",
304 [SMP_SRC_SSFIN] = "session statistics",
305};
306
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100307static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
308 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
309 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
310 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
311 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
312 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
313 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
314 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
315 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
316 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
317 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
318 [SMP_CKP_BE_SRV_CON] = "server source selection",
319 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
320 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
321 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
322 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
323 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
324 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
325 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
326 [SMP_CKP_FE_LOG_END] = "logs",
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100327 [SMP_CKP_BE_CHK_RUL] = "backend tcp-check rule",
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100328};
329
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100330/* This function returns the type of the data returned by the sample_expr.
331 * It assumes that the <expr> and all of its converters are properly
332 * initialized.
333 */
334inline
335int smp_expr_output_type(struct sample_expr *expr)
336{
337 struct sample_conv_expr *smp_expr;
338
339 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
340 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
341 return smp_expr->conv->out_type;
342 }
343 return expr->fetch->out_type;
344}
345
346
Willy Tarreau80aca902013-01-07 15:42:20 +0100347/* fill the trash with a comma-delimited list of source names for the <use> bit
348 * field which must be composed of a non-null set of SMP_USE_* flags. The return
349 * value is the pointer to the string in the trash buffer.
350 */
351const char *sample_src_names(unsigned int use)
352{
353 int bit;
354
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200355 trash.data = 0;
356 trash.area[0] = '\0';
Willy Tarreau80aca902013-01-07 15:42:20 +0100357 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
358 if (!(use & ~((1 << bit) - 1)))
359 break; /* no more bits */
360
361 if (!(use & (1 << bit)))
362 continue; /* bit not set */
363
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200364 trash.data += snprintf(trash.area + trash.data,
365 trash.size - trash.data, "%s%s",
366 (use & ((1 << bit) - 1)) ? "," : "",
367 fetch_src_names[bit]);
Willy Tarreau80aca902013-01-07 15:42:20 +0100368 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200369 return trash.area;
Willy Tarreau80aca902013-01-07 15:42:20 +0100370}
371
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100372/* return a pointer to the correct sample checkpoint name, or "unknown" when
373 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
374 * if set.
375 */
376const char *sample_ckp_names(unsigned int use)
377{
378 int bit;
379
380 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
381 if (use & (1 << bit))
382 return fetch_ckp_names[bit];
383 return "unknown sample check place, please report this bug";
384}
385
Emeric Brun107ca302010-01-04 16:16:05 +0100386/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100387 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
388 * for next parsing sessions. The fetch keywords capabilities are also computed
389 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100390 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100391void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100392{
Willy Tarreau80aca902013-01-07 15:42:20 +0100393 struct sample_fetch *sf;
394 int bit;
395
396 for (sf = kwl->kw; sf->kw != NULL; sf++) {
397 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
398 if (sf->use & (1 << bit))
399 sf->val |= fetch_cap[bit];
400 }
Willy Tarreau2b718102021-04-21 07:32:39 +0200401 LIST_APPEND(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100402}
403
404/*
Willy Tarreau12785782012-04-27 21:37:17 +0200405 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100406 * parsing sessions.
407 */
Willy Tarreau12785782012-04-27 21:37:17 +0200408void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100409{
Willy Tarreau2b718102021-04-21 07:32:39 +0200410 LIST_APPEND(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100411}
412
413/*
Willy Tarreau12785782012-04-27 21:37:17 +0200414 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100415 * string of <len> in buffer <kw>.
416 *
417 */
Willy Tarreau12785782012-04-27 21:37:17 +0200418struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100419{
420 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200421 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100422
Willy Tarreau12785782012-04-27 21:37:17 +0200423 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100424 for (index = 0; kwl->kw[index].kw != NULL; index++) {
425 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
426 kwl->kw[index].kw[len] == '\0')
427 return &kwl->kw[index];
428 }
429 }
430 return NULL;
431}
432
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100433/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100434 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100435 * <idx> is the index of the next sample fetch entry. It is used as private
436 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100437 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100438 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100439 * the list is reached.
440 */
441struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
442{
443 struct sample_fetch_kw_list *kwl;
444 struct sample_fetch *base;
445
446 if (!current) {
447 /* Get first kwl entry. */
448 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
449 (*idx) = 0;
450 } else {
451 /* Get kwl corresponding to the curret entry. */
452 base = current + 1 - (*idx);
453 kwl = container_of(base, struct sample_fetch_kw_list, kw);
454 }
455
456 while (1) {
457
458 /* Check if kwl is the last entry. */
459 if (&kwl->list == &sample_fetches.list)
460 return NULL;
461
462 /* idx contain the next keyword. If it is available, return it. */
463 if (kwl->kw[*idx].kw) {
464 (*idx)++;
465 return &kwl->kw[(*idx)-1];
466 }
467
468 /* get next entry in the main list, and return NULL if the end is reached. */
469 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
470
471 /* Set index to 0, ans do one other loop. */
472 (*idx) = 0;
473 }
474}
475
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100476/* This function browses the list of available converters. <current> is
477 * the last used converter. If it is the first call, it must set to NULL.
478 * <idx> is the index of the next converter entry. It is used as private
479 * value. It is useless to initiate it.
480 *
481 * It returns always the next sample_conv entry, and NULL when the end of
482 * the list is reached.
483 */
484struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
485{
486 struct sample_conv_kw_list *kwl;
487 struct sample_conv *base;
488
489 if (!current) {
490 /* Get first kwl entry. */
491 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
492 (*idx) = 0;
493 } else {
494 /* Get kwl corresponding to the curret entry. */
495 base = current + 1 - (*idx);
496 kwl = container_of(base, struct sample_conv_kw_list, kw);
497 }
498
499 while (1) {
500 /* Check if kwl is the last entry. */
501 if (&kwl->list == &sample_convs.list)
502 return NULL;
503
504 /* idx contain the next keyword. If it is available, return it. */
505 if (kwl->kw[*idx].kw) {
506 (*idx)++;
507 return &kwl->kw[(*idx)-1];
508 }
509
510 /* get next entry in the main list, and return NULL if the end is reached. */
511 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
512
513 /* Set index to 0, ans do one other loop. */
514 (*idx) = 0;
515 }
516}
517
Emeric Brun107ca302010-01-04 16:16:05 +0100518/*
Willy Tarreau12785782012-04-27 21:37:17 +0200519 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100520 * string of <len> in buffer <kw>.
521 *
522 */
Willy Tarreau12785782012-04-27 21:37:17 +0200523struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100524{
525 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200526 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100527
Willy Tarreau12785782012-04-27 21:37:17 +0200528 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100529 for (index = 0; kwl->kw[index].kw != NULL; index++) {
530 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
531 kwl->kw[index].kw[len] == '\0')
532 return &kwl->kw[index];
533 }
534 }
535 return NULL;
536}
537
Emeric Brun107ca302010-01-04 16:16:05 +0100538/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200539/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100540/******************************************************************/
541
Willy Tarreau342acb42012-04-23 22:03:39 +0200542static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100543{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200544 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200545 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100546 return 1;
547}
548
Willy Tarreau342acb42012-04-23 22:03:39 +0200549static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100550{
Willy Tarreau83061a82018-07-13 11:56:34 +0200551 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100552
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200553 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100554 return 0;
555
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200556 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200557 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200558 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100559 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100560
561 return 1;
562}
563
Willy Tarreau342acb42012-04-23 22:03:39 +0200564static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100565{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200566 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200567 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100568 return 1;
569}
570
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200571static int c_ipv62ip(struct sample *smp)
572{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200573 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200574 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100575 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200576 return 1;
577}
578
Willy Tarreau342acb42012-04-23 22:03:39 +0200579static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100580{
Willy Tarreau83061a82018-07-13 11:56:34 +0200581 struct buffer *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100582
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200583 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100584 return 0;
585
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200586 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200587 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200588 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100589 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100590 return 1;
591}
592
593/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200594static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100595{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200596 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100597}
598*/
599
Willy Tarreau342acb42012-04-23 22:03:39 +0200600static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100601{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200602 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200603 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100604 return 1;
605}
606
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200607static int c_int2ipv6(struct sample *smp)
608{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200609 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
610 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200611 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200612 return 1;
613}
614
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100615static int c_str2addr(struct sample *smp)
616{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200617 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4)) {
618 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100619 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200620 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100621 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100622 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100623 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200624 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100625 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100626 return 1;
627}
628
Willy Tarreau342acb42012-04-23 22:03:39 +0200629static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100630{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200631 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100632 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200633 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100634 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100635 return 1;
636}
637
Willy Tarreau342acb42012-04-23 22:03:39 +0200638static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100639{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200640 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100641 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200642 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100643 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100644 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100645}
646
Emeric Brun4b9e8022014-11-03 18:17:10 +0100647/*
648 * The NULL char always enforces the end of string if it is met.
649 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100650 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200651static int c_bin2str(struct sample *smp)
652{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100653 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200654
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200655 for (i = 0; i < smp->data.u.str.data; i++) {
656 if (!smp->data.u.str.area[i]) {
657 smp->data.u.str.data = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100658 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100659 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200660 }
Christopher Faulet472ad512020-04-30 09:57:40 +0200661 smp->data.type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200662 return 1;
663}
664
Willy Tarreau342acb42012-04-23 22:03:39 +0200665static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100666{
Willy Tarreau83061a82018-07-13 11:56:34 +0200667 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100668 char *pos;
669
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200670 pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100671 if (!pos)
672 return 0;
673
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200674 trash->size = trash->size - (pos - trash->area);
675 trash->area = pos;
676 trash->data = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200677 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200678 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100679 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100680 return 1;
681}
682
Joseph Herlant757f5ad2018-11-15 12:14:56 -0800683/* This function unconditionally duplicates data and removes the "const" flag.
Willy Tarreauad635822016-08-08 19:21:09 +0200684 * For strings and binary blocks, it also provides a known allocated size with
685 * a length that is capped to the size, and ensures a trailing zero is always
686 * appended for strings. This is necessary for some operations which may
687 * require to extend the length. It returns 0 if it fails, 1 on success.
688 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100689int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200690{
Willy Tarreau83061a82018-07-13 11:56:34 +0200691 struct buffer *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200692
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200693 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100694 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100695 case SMP_T_SINT:
696 case SMP_T_ADDR:
697 case SMP_T_IPV4:
698 case SMP_T_IPV6:
699 /* These type are not const. */
700 break;
Willy Tarreauad635822016-08-08 19:21:09 +0200701
Christopher Fauletec100512017-07-24 15:38:41 +0200702 case SMP_T_METH:
703 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
704 break;
705 /* Fall through */
706
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100707 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200708 trash = get_trash_chunk();
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100709 trash->data = smp->data.type == SMP_T_STR ?
710 smp->data.u.str.data : smp->data.u.meth.str.data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200711 if (trash->data > trash->size - 1)
712 trash->data = trash->size - 1;
Willy Tarreauad635822016-08-08 19:21:09 +0200713
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100714 memcpy(trash->area, smp->data.type == SMP_T_STR ?
715 smp->data.u.str.area : smp->data.u.meth.str.area,
716 trash->data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200717 trash->area[trash->data] = 0;
Willy Tarreauad635822016-08-08 19:21:09 +0200718 smp->data.u.str = *trash;
719 break;
720
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100721 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100722 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200723 trash->data = smp->data.u.str.data;
724 if (trash->data > trash->size)
725 trash->data = trash->size;
Willy Tarreauad635822016-08-08 19:21:09 +0200726
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200727 memcpy(trash->area, smp->data.u.str.area, trash->data);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200728 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100729 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200730
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100731 default:
732 /* Other cases are unexpected. */
733 return 0;
734 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100735
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100736 /* remove const flag */
737 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200738 return 1;
739}
740
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100741int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100742{
743 return 1;
744}
745
Willy Tarreau342acb42012-04-23 22:03:39 +0200746static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100747{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200748 const char *str;
749 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100750
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200751 if (smp->data.u.str.data == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100752 return 0;
753
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200754 str = smp->data.u.str.area;
755 end = smp->data.u.str.area + smp->data.u.str.data;
Emeric Brun107ca302010-01-04 16:16:05 +0100756
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200757 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200758 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100759 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100760 return 1;
761}
762
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100763static int c_str2meth(struct sample *smp)
764{
765 enum http_meth_t meth;
766 int len;
767
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200768 meth = find_http_meth(smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100769 if (meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200770 len = smp->data.u.str.data;
771 smp->data.u.meth.str.area = smp->data.u.str.area;
772 smp->data.u.meth.str.data = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100773 }
774 else
775 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200776 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200777 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100778 return 1;
779}
780
781static int c_meth2str(struct sample *smp)
782{
783 int len;
784 enum http_meth_t meth;
785
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200786 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100787 /* The method is unknown. Copy the original pointer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200788 len = smp->data.u.meth.str.data;
789 smp->data.u.str.area = smp->data.u.meth.str.area;
790 smp->data.u.str.data = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200791 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100792 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200793 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100794 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200795 meth = smp->data.u.meth.meth;
Willy Tarreau35b51c62018-09-10 15:38:55 +0200796 smp->data.u.str.area = http_known_methods[meth].ptr;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200797 smp->data.u.str.data = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100798 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200799 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100800 }
801 else {
802 /* Unknown method */
803 return 0;
804 }
805 return 1;
806}
807
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200808static int c_addr2bin(struct sample *smp)
809{
Willy Tarreau83061a82018-07-13 11:56:34 +0200810 struct buffer *chk = get_trash_chunk();
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200811
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200812 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200813 chk->data = 4;
814 memcpy(chk->area, &smp->data.u.ipv4, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200815 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200816 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200817 chk->data = 16;
818 memcpy(chk->area, &smp->data.u.ipv6, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200819 }
820 else
821 return 0;
822
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200823 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200824 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200825 return 1;
826}
827
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200828static int c_int2bin(struct sample *smp)
829{
Willy Tarreau83061a82018-07-13 11:56:34 +0200830 struct buffer *chk = get_trash_chunk();
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200831
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200832 *(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
833 chk->data = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200834
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200835 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200836 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200837 return 1;
838}
839
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200840
Emeric Brun107ca302010-01-04 16:16:05 +0100841/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200842/* Sample casts matrix: */
843/* sample_casts[from type][to type] */
844/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100845/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100846
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100847sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200848/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
849/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
850/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200851/* 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 +0200852/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
853/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200854/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200855/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
856/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
857/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200858};
Emeric Brun107ca302010-01-04 16:16:05 +0100859
Emeric Brun107ca302010-01-04 16:16:05 +0100860/*
Willy Tarreau12785782012-04-27 21:37:17 +0200861 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100862 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200863 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200864 * The caller must have set al->ctx.
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100865 * If <endptr> is non-nul, it will be set to the first unparsed character
866 * (which may be the final '\0') on success. If it is nul, the expression
867 * must be properly terminated by a '\0' otherwise an error is reported.
Emeric Brun107ca302010-01-04 16:16:05 +0100868 */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100869struct 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 +0100870{
Willy Tarreau833cc792013-07-24 15:34:19 +0200871 const char *begw; /* beginning of word */
872 const char *endw; /* end of word */
873 const char *endt; /* end of term */
Remi Tricot-Le Breton22e0d9b2021-01-12 14:55:12 +0100874 struct sample_expr *expr = NULL;
Willy Tarreau12785782012-04-27 21:37:17 +0200875 struct sample_fetch *fetch;
876 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100877 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200878 char *fkw = NULL;
879 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100880 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100881
Willy Tarreau833cc792013-07-24 15:34:19 +0200882 begw = str[*idx];
Willy Tarreaued2c6622020-02-14 18:27:10 +0100883 for (endw = begw; is_idchar(*endw); endw++)
884 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200885
886 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100887 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100888 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200889 }
Emeric Brun107ca302010-01-04 16:16:05 +0100890
Willy Tarreau833cc792013-07-24 15:34:19 +0200891 /* keep a copy of the current fetch keyword for error reporting */
892 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100893
Willy Tarreau833cc792013-07-24 15:34:19 +0200894 fetch = find_sample_fetch(begw, endw - begw);
895 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100896 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100897 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200898 }
Emeric Brun107ca302010-01-04 16:16:05 +0100899
Willy Tarreau833cc792013-07-24 15:34:19 +0200900 /* At this point, we have :
901 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100902 * - endw : end of the keyword, first character not part of keyword
Willy Tarreau833cc792013-07-24 15:34:19 +0200903 */
904
905 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100906 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100907 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200908 }
Emeric Brun107ca302010-01-04 16:16:05 +0100909 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200910
Vincent Bernat02779b62016-04-03 13:48:43 +0200911 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200912 if (!expr)
913 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100914
915 LIST_INIT(&(expr->conv_exprs));
916 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200917 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100918
Willy Tarreau689a1df2013-12-13 00:40:11 +0100919 /* Note that we call the argument parser even with an empty string,
920 * this allows it to automatically create entries for mandatory
921 * implicit arguments (eg: local proxy name).
922 */
923 al->kw = expr->fetch->kw;
924 al->conv = NULL;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100925 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 +0100926 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
927 goto out_error;
928 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200929
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100930 /* now endt is our first char not part of the arg list, typically the
931 * comma after the sample fetch name or after the closing parenthesis,
932 * or the NUL char.
933 */
934
Willy Tarreau689a1df2013-12-13 00:40:11 +0100935 if (!expr->arg_p) {
936 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200937 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100938 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
939 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200940 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100941 }
942
Willy Tarreau833cc792013-07-24 15:34:19 +0200943 /* Now process the converters if any. We have two supported syntaxes
944 * for the converters, which can be combined :
945 * - comma-delimited list of converters just after the keyword and args ;
946 * - one converter per keyword
947 * The combination allows to have each keyword being a comma-delimited
948 * series of converters.
949 *
950 * We want to process the former first, then the latter. For this we start
951 * from the beginning of the supposed place in the exiting conv chain, which
952 * starts at the last comma (endt).
953 */
954
955 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200956 struct sample_conv_expr *conv_expr;
Willy Tarreau46dfd782019-12-17 10:25:29 +0100957 int err_arg;
958 int argcnt;
Emeric Brun107ca302010-01-04 16:16:05 +0100959
Willy Tarreau833cc792013-07-24 15:34:19 +0200960 if (*endt && *endt != ',') {
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100961 if (endptr) {
962 /* end found, let's stop here */
963 break;
964 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200965 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100966 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200967 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100968 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100969 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200970 }
Emeric Brun107ca302010-01-04 16:16:05 +0100971
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100972 /* FIXME: how long should we support such idiocies ? Maybe we
973 * should already warn ?
974 */
Willy Tarreau833cc792013-07-24 15:34:19 +0200975 while (*endt == ',') /* then trailing commas */
976 endt++;
977
Willy Tarreau97108e02016-11-25 07:33:24 +0100978 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200979
980 if (!*begw) {
981 /* none ? skip to next string */
982 (*idx)++;
983 begw = str[*idx];
984 if (!begw || !*begw)
985 break;
986 }
987
Willy Tarreaued2c6622020-02-14 18:27:10 +0100988 for (endw = begw; is_idchar(*endw); endw++)
989 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200990
991 free(ckw);
992 ckw = my_strndup(begw, endw - begw);
993
994 conv = find_sample_conv(begw, endw - begw);
995 if (!conv) {
996 /* we found an isolated keyword that we don't know, it's not ours */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100997 if (begw == str[*idx]) {
998 endt = begw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200999 break;
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001000 }
Willy Tarreau97108e02016-11-25 07:33:24 +01001001 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +02001002 goto out_error;
1003 }
Emeric Brun107ca302010-01-04 16:16:05 +01001004
Willy Tarreau833cc792013-07-24 15:34:19 +02001005 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +01001006 memprintf(err_msg, "returns type of converter '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001007 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +02001008 }
Emeric Brun107ca302010-01-04 16:16:05 +01001009
1010 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +02001011 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +01001012 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001013 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +02001014 }
Emeric Brun107ca302010-01-04 16:16:05 +01001015
1016 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +02001017 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +02001018 if (!conv_expr)
1019 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001020
Willy Tarreau2b718102021-04-21 07:32:39 +02001021 LIST_APPEND(&(expr->conv_exprs), &(conv_expr->list));
Emeric Brun107ca302010-01-04 16:16:05 +01001022 conv_expr->conv = conv;
1023
Willy Tarreau46dfd782019-12-17 10:25:29 +01001024 al->kw = expr->fetch->kw;
1025 al->conv = conv_expr->conv->kw;
Willy Tarreau80b53ff2020-02-14 08:40:37 +01001026 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 +01001027 if (argcnt < 0) {
1028 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
1029 goto out_error;
1030 }
Willy Tarreau9e92d322010-01-26 17:58:06 +01001031
Willy Tarreau46dfd782019-12-17 10:25:29 +01001032 if (argcnt && !conv->arg_mask) {
1033 memprintf(err_msg, "converter '%s' does not support any args", ckw);
1034 goto out_error;
1035 }
Willy Tarreau21d68a62012-04-20 15:52:36 +02001036
Willy Tarreau46dfd782019-12-17 10:25:29 +01001037 if (!conv_expr->arg_p)
1038 conv_expr->arg_p = empty_arg_list;
Willy Tarreau2e845be2012-10-19 19:49:09 +02001039
Willy Tarreau46dfd782019-12-17 10:25:29 +01001040 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
1041 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001042 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001043 }
1044 }
Emeric Brun485479d2010-09-23 18:02:19 +02001045
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001046 if (endptr) {
1047 /* end found, let's stop here */
1048 *endptr = (char *)endt;
1049 }
1050
Willy Tarreau833cc792013-07-24 15:34:19 +02001051 out:
1052 free(fkw);
1053 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001054 return expr;
1055
1056out_error:
Remi Tricot-Le Breton22e0d9b2021-01-12 14:55:12 +01001057 release_sample_expr(expr);
Willy Tarreau833cc792013-07-24 15:34:19 +02001058 expr = NULL;
1059 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001060}
1061
1062/*
Willy Tarreau12785782012-04-27 21:37:17 +02001063 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001064 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001065 * Returns a pointer on a typed sample structure containing the result or NULL if
1066 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001067 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001068 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001069 *
1070 * Note: the fetch functions are required to properly set the return type. The
1071 * conversion functions must do so too. However the cast functions do not need
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001072 * to since they're made to cast multiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001073 *
1074 * The caller may indicate in <opt> if it considers the result final or not.
1075 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1076 * if the result is stable or not, according to the following table :
1077 *
1078 * return MAY_CHANGE FINAL Meaning for the sample
1079 * NULL 0 * Not present and will never be (eg: header)
1080 * NULL 1 0 Not present yet, could change (eg: POST param)
1081 * NULL 1 1 Not present yet, will not change anymore
1082 * smp 0 * Present and will not change (eg: header)
1083 * smp 1 0 Present, may change (eg: request length)
1084 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001085 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001086struct sample *sample_process(struct proxy *px, struct session *sess,
1087 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001088 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001089{
Willy Tarreau12785782012-04-27 21:37:17 +02001090 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001091
Willy Tarreau18387e22013-07-25 12:02:38 +02001092 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001093 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001094 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001095 }
Emeric Brun107ca302010-01-04 16:16:05 +01001096
Willy Tarreau1777ea62016-03-10 16:15:46 +01001097 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001098 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001099 return NULL;
1100
Emeric Brun107ca302010-01-04 16:16:05 +01001101 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001102 /* we want to ensure that p->type can be casted into
1103 * conv_expr->conv->in_type. We have 3 possibilities :
1104 * - NULL => not castable.
1105 * - c_none => nothing to do (let's optimize it)
1106 * - other => apply cast and prepare to fail
1107 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001108 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001109 return NULL;
1110
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001111 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1112 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001113 return NULL;
1114
Willy Tarreau12e50112012-04-25 17:21:49 +02001115 /* OK cast succeeded */
1116
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001117 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001118 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001119 }
1120 return p;
1121}
1122
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001123/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001124 * Resolve all remaining arguments in proxy <p>. Returns the number of
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001125 * errors or 0 if everything is fine. If at least one error is met, it will
1126 * be appended to *err. If *err==NULL it will be allocated first.
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001127 */
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001128int smp_resolve_args(struct proxy *p, char **err)
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001129{
1130 struct arg_list *cur, *bak;
1131 const char *ctx, *where;
1132 const char *conv_ctx, *conv_pre, *conv_pos;
1133 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001134 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001135 struct arg *arg;
1136 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001137 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001138
1139 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1140 struct proxy *px;
1141 struct server *srv;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001142 struct stktable *t;
1143 char *pname, *sname, *stktname;
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001144 char *err2;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001145
1146 arg = cur->arg;
1147
1148 /* prepare output messages */
1149 conv_pre = conv_pos = conv_ctx = "";
1150 if (cur->conv) {
1151 conv_ctx = cur->conv;
1152 conv_pre = "conversion keyword '";
1153 conv_pos = "' for ";
1154 }
1155
1156 where = "in";
1157 ctx = "sample fetch keyword";
1158 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001159 case ARGC_STK: where = "in stick rule in"; break;
1160 case ARGC_TRK: where = "in tracking rule in"; break;
1161 case ARGC_LOG: where = "in log-format string in"; break;
1162 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1163 case ARGC_HRQ: where = "in http-request header format string in"; break;
1164 case ARGC_HRS: where = "in http-response header format string in"; break;
1165 case ARGC_UIF: where = "in unique-id-format string in"; break;
1166 case ARGC_RDR: where = "in redirect format string in"; break;
1167 case ARGC_CAP: where = "in capture rule in"; break;
1168 case ARGC_ACL: ctx = "ACL keyword"; break;
1169 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001170 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Christopher Faulet3b967c12020-05-15 15:47:44 +02001171 case ARGC_HERR: where = "in http-error directive in"; break;
Miroslav Zagorac7f8314c2020-12-09 16:31:48 +01001172 case ARGC_OT: where = "in ot-scope directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001173 }
1174
1175 /* set a few default settings */
1176 px = p;
1177 pname = p->id;
1178
1179 switch (arg->type) {
1180 case ARGT_SRV:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001181 if (!arg->data.str.data) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001182 memprintf(err, "%sparsing [%s:%d]: missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1183 *err ? *err : "", cur->file, cur->line,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001184 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001185 cfgerr++;
1186 continue;
1187 }
1188
1189 /* we support two formats : "bck/srv" and "srv" */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001190 sname = strrchr(arg->data.str.area, '/');
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001191
1192 if (sname) {
1193 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001194 pname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001195
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001196 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001197 if (!px) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001198 memprintf(err, "%sparsing [%s:%d]: unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1199 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001200 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001201 cfgerr++;
1202 break;
1203 }
1204 }
1205 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001206 sname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001207
1208 srv = findserver(px, sname);
1209 if (!srv) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001210 memprintf(err, "%sparsing [%s:%d]: unable to find server '%s' in proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1211 *err ? *err : "", cur->file, cur->line, sname, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001212 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001213 cfgerr++;
1214 break;
1215 }
1216
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001217 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001218 arg->unresolved = 0;
1219 arg->data.srv = srv;
1220 break;
1221
1222 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001223 if (arg->data.str.data) {
1224 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001225 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001226 }
1227
1228 if (!px) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001229 memprintf(err, "%sparsing [%s:%d]: unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1230 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001231 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001232 cfgerr++;
1233 break;
1234 }
1235
1236 if (!(px->cap & PR_CAP_FE)) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001237 memprintf(err, "%sparsing [%s:%d]: proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1238 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001239 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001240 cfgerr++;
1241 break;
1242 }
1243
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001244 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001245 arg->unresolved = 0;
1246 arg->data.prx = px;
1247 break;
1248
1249 case ARGT_BE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001250 if (arg->data.str.data) {
1251 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001252 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001253 }
1254
1255 if (!px) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001256 memprintf(err, "%sparsing [%s:%d]: unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1257 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001258 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001259 cfgerr++;
1260 break;
1261 }
1262
1263 if (!(px->cap & PR_CAP_BE)) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001264 memprintf(err, "%sparsing [%s:%d]: proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1265 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001266 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001267 cfgerr++;
1268 break;
1269 }
1270
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001271 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001272 arg->unresolved = 0;
1273 arg->data.prx = px;
1274 break;
1275
1276 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001277 if (arg->data.str.data)
1278 stktname = arg->data.str.area;
1279 else
1280 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001281
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001282 t = stktable_find_by_name(stktname);
1283 if (!t) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001284 memprintf(err, "%sparsing [%s:%d]: unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1285 *err ? *err : "", cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001286 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001287 cfgerr++;
1288 break;
1289 }
1290
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001291 if (!t->size) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001292 memprintf(err, "%sparsing [%s:%d]: no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1293 *err ? *err : "", cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001294 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001295 cfgerr++;
1296 break;
1297 }
1298
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001299 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001300 memprintf(err, "%sparsing [%s:%d]: stick-table '%s' not present on all processes covered by proxy '%s'.\n",
1301 *err ? *err : "", cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001302 cfgerr++;
1303 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001304 }
1305
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001306 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001307 p->next_stkt_ref = t->proxies_list;
1308 t->proxies_list = p;
1309 }
1310
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001311 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001312 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001313 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001314 break;
1315
1316 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001317 if (!arg->data.str.data) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001318 memprintf(err, "%sparsing [%s:%d]: missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1319 *err ? *err : "", cur->file, cur->line,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001320 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001321 cfgerr++;
1322 break;
1323 }
1324
1325 if (p->uri_auth && p->uri_auth->userlist &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001326 strcmp(p->uri_auth->userlist->name, arg->data.str.area) == 0)
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001327 ul = p->uri_auth->userlist;
1328 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001329 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001330
1331 if (!ul) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001332 memprintf(err, "%sparsing [%s:%d]: unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1333 *err ? *err : "", cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001334 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001335 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001336 cfgerr++;
1337 break;
1338 }
1339
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001340 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001341 arg->unresolved = 0;
1342 arg->data.usr = ul;
1343 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001344
1345 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001346 if (!arg->data.str.data) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001347 memprintf(err, "%sparsing [%s:%d]: missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1348 *err ? *err : "", cur->file, cur->line,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001349 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001350 cfgerr++;
1351 continue;
1352 }
1353
Willy Tarreau46947782015-01-19 19:00:58 +01001354 rflags = 0;
1355 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001356 err2 = NULL;
Willy Tarreau46947782015-01-19 19:00:58 +01001357
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001358 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err2))) {
1359 memprintf(err, "%sparsing [%s:%d]: error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1360 *err ? *err : "", cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001361 arg->data.str.area,
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001362 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err2);
Willy Tarreau46947782015-01-19 19:00:58 +01001363 cfgerr++;
1364 continue;
1365 }
1366
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001367 chunk_destroy(&arg->data.str);
Willy Tarreau46947782015-01-19 19:00:58 +01001368 arg->unresolved = 0;
1369 arg->data.reg = reg;
1370 break;
1371
1372
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001373 }
1374
Willy Tarreau2b718102021-04-21 07:32:39 +02001375 LIST_DELETE(&cur->list);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001376 free(cur);
1377 } /* end of args processing */
1378
1379 return cfgerr;
1380}
1381
1382/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001383 * Process a fetch + format conversion as defined by the sample expression
1384 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001385 * not explicitly set to <smp_type>, but shall be compatible with it as
1386 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1387 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001388 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1389 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1390 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1391 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001392 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1393 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1394 * still hope to get it after waiting longer, and is not converted to string.
1395 * The possible output combinations are the following :
1396 *
1397 * return MAY_CHANGE FINAL Meaning for the sample
1398 * NULL * * Not present and will never be (eg: header)
1399 * smp 0 * Final value converted (eg: header)
1400 * smp 1 0 Not present yet, may appear later (eg: header)
1401 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001402 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001403struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001404 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001405 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001406{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001407 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001408
Willy Tarreau6c616e02014-06-25 16:56:41 +02001409 memset(smp, 0, sizeof(*smp));
1410
Willy Tarreau192252e2015-04-04 01:47:55 +02001411 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001412 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1413 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001414 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001415 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001416
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001417 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001418 return NULL;
1419
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001420 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001421 return NULL;
1422
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001423 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001424 return smp;
1425}
1426
Christopher Faulet476e5d02016-10-26 11:34:47 +02001427static void release_sample_arg(struct arg *p)
1428{
1429 struct arg *p_back = p;
1430
1431 if (!p)
1432 return;
1433
1434 while (p->type != ARGT_STOP) {
1435 if (p->type == ARGT_STR || p->unresolved) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001436 chunk_destroy(&p->data.str);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001437 p->unresolved = 0;
1438 }
1439 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001440 regex_free(p->data.reg);
1441 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001442 }
1443 p++;
1444 }
1445
1446 if (p_back != empty_arg_list)
1447 free(p_back);
1448}
1449
1450void release_sample_expr(struct sample_expr *expr)
1451{
1452 struct sample_conv_expr *conv_expr, *conv_exprb;
1453
1454 if (!expr)
1455 return;
1456
Tim Duesterhus867cd982020-07-04 11:49:39 +02001457 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001458 LIST_DELETE(&conv_expr->list);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001459 release_sample_arg(conv_expr->arg_p);
Tim Duesterhus867cd982020-07-04 11:49:39 +02001460 free(conv_expr);
1461 }
1462
Christopher Faulet476e5d02016-10-26 11:34:47 +02001463 release_sample_arg(expr->arg_p);
1464 free(expr);
1465}
1466
Emeric Brun107ca302010-01-04 16:16:05 +01001467/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001468/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001469/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001470/*****************************************************************/
1471
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001472static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1473{
1474 int i;
1475 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001476 struct buffer *buf;
1477 struct sink *sink;
1478 struct ist line;
1479 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001480
Willy Tarreau0851fd52019-12-17 10:07:25 +01001481 buf = alloc_trash_chunk();
1482 if (!buf)
1483 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001484
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001485 sink = (struct sink *)arg_p[1].data.ptr;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001486 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001487
Willy Tarreau0851fd52019-12-17 10:07:25 +01001488 pfx = arg_p[0].data.str.area;
1489 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001490
Willy Tarreau0851fd52019-12-17 10:07:25 +01001491 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1492 if (!sample_casts[smp->data.type][SMP_T_STR])
1493 goto nocast;
1494
1495 /* Copy sample fetch. This puts the sample as const, the
1496 * cast will copy data if a transformation is required.
1497 */
1498 memcpy(&tmp, smp, sizeof(struct sample));
1499 tmp.flags = SMP_F_CONST;
1500
1501 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1502 goto nocast;
1503
1504 /* Display the displayable chars*. */
1505 b_putchr(buf, '<');
1506 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001507 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001508 b_putchr(buf, tmp.data.u.str.area[i]);
1509 else
1510 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001511 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001512 b_putchr(buf, '>');
1513
1514 done:
1515 line = ist2(buf->area, buf->data);
Emeric Brun54648852020-07-06 15:54:06 +02001516 sink_write(sink, &line, 1, 0, 0, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001517 end:
1518 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001519 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001520 nocast:
1521 chunk_appendf(buf, "(undisplayable)");
1522 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001523}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001524
1525// This function checks the "debug" converter's arguments.
1526static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1527 const char *file, int line, char **err)
1528{
1529 const char *name = "buf0";
1530 struct sink *sink = NULL;
1531
1532 if (args[0].type != ARGT_STR) {
1533 /* optional prefix */
1534 args[0].data.str.area = "";
1535 args[0].data.str.data = 0;
1536 }
1537
1538 if (args[1].type == ARGT_STR)
1539 name = args[1].data.str.area;
1540
1541 sink = sink_find(name);
1542 if (!sink) {
1543 memprintf(err, "No such sink '%s'", name);
1544 return 0;
1545 }
1546
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001547 chunk_destroy(&args[1].data.str);
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001548 args[1].type = ARGT_PTR;
1549 args[1].data.ptr = sink;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001550 return 1;
1551}
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001552
Holger Just1bfc24b2017-05-06 00:56:53 +02001553static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1554{
Willy Tarreau83061a82018-07-13 11:56:34 +02001555 struct buffer *trash = get_trash_chunk();
Holger Just1bfc24b2017-05-06 00:56:53 +02001556 int bin_len;
1557
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001558 trash->data = 0;
1559 bin_len = base64dec(smp->data.u.str.area, smp->data.u.str.data,
1560 trash->area, trash->size);
Holger Just1bfc24b2017-05-06 00:56:53 +02001561 if (bin_len < 0)
1562 return 0;
1563
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001564 trash->data = bin_len;
Holger Just1bfc24b2017-05-06 00:56:53 +02001565 smp->data.u.str = *trash;
1566 smp->data.type = SMP_T_BIN;
1567 smp->flags &= ~SMP_F_CONST;
1568 return 1;
1569}
1570
Moemen MHEDHBI92f7d432021-04-01 20:53:59 +02001571static int sample_conv_base64url2bin(const struct arg *arg_p, struct sample *smp, void *private)
1572{
1573 struct buffer *trash = get_trash_chunk();
1574 int bin_len;
1575
1576 trash->data = 0;
1577 bin_len = base64urldec(smp->data.u.str.area, smp->data.u.str.data,
1578 trash->area, trash->size);
1579 if (bin_len < 0)
1580 return 0;
1581
1582 trash->data = bin_len;
1583 smp->data.u.str = *trash;
1584 smp->data.type = SMP_T_BIN;
1585 smp->flags &= ~SMP_F_CONST;
1586 return 1;
1587}
1588
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001589static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001590{
Willy Tarreau83061a82018-07-13 11:56:34 +02001591 struct buffer *trash = get_trash_chunk();
Emeric Brun53d1a982014-04-30 18:21:37 +02001592 int b64_len;
1593
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001594 trash->data = 0;
1595 b64_len = a2base64(smp->data.u.str.area, smp->data.u.str.data,
1596 trash->area, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001597 if (b64_len < 0)
1598 return 0;
1599
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001600 trash->data = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001601 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001602 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001603 smp->flags &= ~SMP_F_CONST;
1604 return 1;
1605}
1606
Moemen MHEDHBI92f7d432021-04-01 20:53:59 +02001607static int sample_conv_bin2base64url(const struct arg *arg_p, struct sample *smp, void *private)
1608{
1609 struct buffer *trash = get_trash_chunk();
1610 int b64_len;
1611
1612 trash->data = 0;
1613 b64_len = a2base64url(smp->data.u.str.area, smp->data.u.str.data,
1614 trash->area, trash->size);
1615 if (b64_len < 0)
1616 return 0;
1617
1618 trash->data = b64_len;
1619 smp->data.u.str = *trash;
1620 smp->data.type = SMP_T_STR;
1621 smp->flags &= ~SMP_F_CONST;
1622 return 1;
1623}
1624
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001625static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1626{
1627 blk_SHA_CTX ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001628 struct buffer *trash = get_trash_chunk();
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001629
1630 memset(&ctx, 0, sizeof(ctx));
1631
1632 blk_SHA1_Init(&ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001633 blk_SHA1_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1634 blk_SHA1_Final((unsigned char *) trash->area, &ctx);
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001635
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001636 trash->data = 20;
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001637 smp->data.u.str = *trash;
1638 smp->data.type = SMP_T_BIN;
1639 smp->flags &= ~SMP_F_CONST;
1640 return 1;
1641}
1642
Tim Duesterhusd4376302019-06-17 12:41:44 +02001643#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01001644static int smp_check_sha2(struct arg *args, struct sample_conv *conv,
1645 const char *file, int line, char **err)
1646{
1647 if (args[0].type == ARGT_STOP)
1648 return 1;
1649 if (args[0].type != ARGT_SINT) {
1650 memprintf(err, "Invalid type '%s'", arg_type_names[args[0].type]);
1651 return 0;
1652 }
1653
1654 switch (args[0].data.sint) {
1655 case 224:
1656 case 256:
1657 case 384:
1658 case 512:
1659 /* this is okay */
1660 return 1;
1661 default:
1662 memprintf(err, "Unsupported number of bits: '%lld'", args[0].data.sint);
1663 return 0;
1664 }
1665}
1666
Tim Duesterhusd4376302019-06-17 12:41:44 +02001667static int sample_conv_sha2(const struct arg *arg_p, struct sample *smp, void *private)
1668{
1669 struct buffer *trash = get_trash_chunk();
1670 int bits = 256;
Christopher Faulete6e7a582021-01-29 11:29:28 +01001671 if (arg_p->data.sint)
Tim Duesterhusd4376302019-06-17 12:41:44 +02001672 bits = arg_p->data.sint;
1673
1674 switch (bits) {
1675 case 224: {
1676 SHA256_CTX ctx;
1677
1678 memset(&ctx, 0, sizeof(ctx));
1679
1680 SHA224_Init(&ctx);
1681 SHA224_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1682 SHA224_Final((unsigned char *) trash->area, &ctx);
1683 trash->data = SHA224_DIGEST_LENGTH;
1684 break;
1685 }
1686 case 256: {
1687 SHA256_CTX ctx;
1688
1689 memset(&ctx, 0, sizeof(ctx));
1690
1691 SHA256_Init(&ctx);
1692 SHA256_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1693 SHA256_Final((unsigned char *) trash->area, &ctx);
1694 trash->data = SHA256_DIGEST_LENGTH;
1695 break;
1696 }
1697 case 384: {
1698 SHA512_CTX ctx;
1699
1700 memset(&ctx, 0, sizeof(ctx));
1701
1702 SHA384_Init(&ctx);
1703 SHA384_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1704 SHA384_Final((unsigned char *) trash->area, &ctx);
1705 trash->data = SHA384_DIGEST_LENGTH;
1706 break;
1707 }
1708 case 512: {
1709 SHA512_CTX ctx;
1710
1711 memset(&ctx, 0, sizeof(ctx));
1712
1713 SHA512_Init(&ctx);
1714 SHA512_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1715 SHA512_Final((unsigned char *) trash->area, &ctx);
1716 trash->data = SHA512_DIGEST_LENGTH;
1717 break;
1718 }
1719 default:
1720 return 0;
1721 }
1722
1723 smp->data.u.str = *trash;
1724 smp->data.type = SMP_T_BIN;
1725 smp->flags &= ~SMP_F_CONST;
1726 return 1;
1727}
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001728
Dragan Dosen9e8db132021-02-22 10:03:53 +01001729/* This function returns a sample struct filled with an <arg> content.
1730 * If the <arg> contains a string, it is returned in the sample flagged as
1731 * SMP_F_CONST. If the <arg> contains a variable descriptor, the sample is
1732 * filled with the content of the variable by using vars_get_by_desc().
1733 *
1734 * Keep in mind that the sample content may be written to a pre-allocated
1735 * trash chunk as returned by get_trash_chunk().
1736 *
1737 * This function returns 0 if an error occurs, otherwise it returns 1.
1738 */
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001739static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
1740{
1741 switch (arg->type) {
1742 case ARGT_STR:
1743 smp->data.type = SMP_T_STR;
1744 smp->data.u.str = arg->data.str;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001745 smp->flags = SMP_F_CONST;
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001746 return 1;
1747 case ARGT_VAR:
1748 if (!vars_get_by_desc(&arg->data.var, smp))
1749 return 0;
1750 if (!sample_casts[smp->data.type][SMP_T_STR])
1751 return 0;
1752 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
1753 return 0;
1754 return 1;
1755 default:
1756 return 0;
1757 }
1758}
1759
Dragan Dosen9e8db132021-02-22 10:03:53 +01001760/* This function checks an <arg> and fills it with a variable type if the
1761 * <arg> string contains a valid variable name. If failed, the function
1762 * tries to perform a base64 decode operation on the same string, and
1763 * fills the <arg> with the decoded content.
1764 *
1765 * Validation is skipped if the <arg> string is empty.
1766 *
1767 * This function returns 0 if the variable lookup fails and the specified
1768 * <arg> string is not a valid base64 encoded string, as well if
1769 * unexpected argument type is specified or memory allocation error
1770 * occurs. Otherwise it returns 1.
1771 */
1772static inline int sample_check_arg_base64(struct arg *arg, char **err)
1773{
1774 char *dec = NULL;
1775 int dec_size;
1776
1777 if (arg->type != ARGT_STR) {
1778 memprintf(err, "unexpected argument type");
1779 return 0;
1780 }
1781
1782 if (arg->data.str.data == 0) /* empty */
1783 return 1;
1784
1785 if (vars_check_arg(arg, NULL))
1786 return 1;
1787
1788 if (arg->data.str.data % 4) {
1789 memprintf(err, "argument needs to be base64 encoded, and "
1790 "can either be a string or a variable");
1791 return 0;
1792 }
1793
1794 dec_size = (arg->data.str.data / 4 * 3)
1795 - (arg->data.str.area[arg->data.str.data-1] == '=' ? 1 : 0)
1796 - (arg->data.str.area[arg->data.str.data-2] == '=' ? 1 : 0);
1797
1798 if ((dec = malloc(dec_size)) == NULL) {
1799 memprintf(err, "memory allocation error");
1800 return 0;
1801 }
1802
1803 dec_size = base64dec(arg->data.str.area, arg->data.str.data, dec, dec_size);
1804 if (dec_size < 0) {
1805 memprintf(err, "argument needs to be base64 encoded, and "
1806 "can either be a string or a variable");
1807 free(dec);
1808 return 0;
1809 }
1810
1811 /* base64 decoded */
1812 chunk_destroy(&arg->data.str);
1813 arg->data.str.area = dec;
1814 arg->data.str.data = dec_size;
1815 return 1;
1816}
1817
Ilya Shipitsin2c481d02021-03-26 23:35:31 +05001818#ifdef EVP_CIPH_GCM_MODE
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001819static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
1820 const char *file, int line, char **err)
1821{
1822 switch(args[0].data.sint) {
1823 case 128:
1824 case 192:
1825 case 256:
1826 break;
1827 default:
1828 memprintf(err, "key size must be 128, 192 or 256 (bits).");
1829 return 0;
1830 }
Dragan Dosen9e8db132021-02-22 10:03:53 +01001831
1832 /* Try to decode variables. */
1833 if (!sample_check_arg_base64(&args[1], err)) {
1834 memprintf(err, "failed to parse nonce : %s", *err);
1835 return 0;
1836 }
1837 if (!sample_check_arg_base64(&args[2], err)) {
1838 memprintf(err, "failed to parse key : %s", *err);
1839 return 0;
1840 }
1841 if (!sample_check_arg_base64(&args[3], err)) {
1842 memprintf(err, "failed to parse aead_tag : %s", *err);
1843 return 0;
1844 }
1845
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001846 return 1;
1847}
1848
1849/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
1850static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
1851{
1852 struct sample nonce, key, aead_tag;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001853 struct buffer *smp_trash = NULL, *smp_trash_alloc = NULL;
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001854 EVP_CIPHER_CTX *ctx;
1855 int dec_size, ret;
1856
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001857 smp_trash_alloc = alloc_trash_chunk();
1858 if (!smp_trash_alloc)
1859 return 0;
1860
Dragan Dosen9e8db132021-02-22 10:03:53 +01001861 /* smp copy */
1862 smp_trash_alloc->data = smp->data.u.str.data;
1863 if (unlikely(smp_trash_alloc->data > smp_trash_alloc->size))
1864 smp_trash_alloc->data = smp_trash_alloc->size;
1865 memcpy(smp_trash_alloc->area, smp->data.u.str.area, smp_trash_alloc->data);
1866
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001867 ctx = EVP_CIPHER_CTX_new();
1868
1869 if (!ctx)
1870 goto err;
1871
Dragan Dosen9e8db132021-02-22 10:03:53 +01001872 smp_trash = alloc_trash_chunk();
1873 if (!smp_trash)
1874 goto err;
1875
1876 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
1877 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001878 goto err;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001879
1880 if (arg_p[1].type == ARGT_VAR) {
1881 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
1882 if (dec_size < 0)
1883 goto err;
1884 smp_trash->data = dec_size;
1885 nonce.data.u.str = *smp_trash;
1886 }
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001887
1888 /* Set cipher type and mode */
1889 switch(arg_p[0].data.sint) {
1890 case 128:
1891 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
1892 break;
1893 case 192:
1894 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
1895 break;
1896 case 256:
1897 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
1898 break;
1899 }
1900
Dragan Dosen9e8db132021-02-22 10:03:53 +01001901 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, nonce.data.u.str.data, NULL);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001902
1903 /* Initialise IV */
Dragan Dosen9e8db132021-02-22 10:03:53 +01001904 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) nonce.data.u.str.area))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001905 goto err;
1906
Dragan Dosen9e8db132021-02-22 10:03:53 +01001907 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1908 if (!sample_conv_var2smp_str(&arg_p[2], &key))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001909 goto err;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001910
1911 if (arg_p[2].type == ARGT_VAR) {
1912 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
1913 if (dec_size < 0)
1914 goto err;
1915 smp_trash->data = dec_size;
1916 key.data.u.str = *smp_trash;
1917 }
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001918
1919 /* Initialise key */
Dragan Dosen9e8db132021-02-22 10:03:53 +01001920 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) key.data.u.str.area, NULL))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001921 goto err;
1922
1923 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
Dragan Dosen9e8db132021-02-22 10:03:53 +01001924 (unsigned char *) smp_trash_alloc->area, (int) smp_trash_alloc->data))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001925 goto err;
1926
Dragan Dosen9e8db132021-02-22 10:03:53 +01001927 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
1928 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001929 goto err;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001930
1931 if (arg_p[3].type == ARGT_VAR) {
1932 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
1933 if (dec_size < 0)
1934 goto err;
1935 smp_trash_alloc->data = dec_size;
1936 aead_tag.data.u.str = *smp_trash_alloc;
1937 }
1938
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001939 dec_size = smp_trash->data;
1940
Dragan Dosen9e8db132021-02-22 10:03:53 +01001941 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, aead_tag.data.u.str.data, (void *) aead_tag.data.u.str.area);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001942 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
1943
1944 if (ret <= 0)
1945 goto err;
1946
1947 smp->data.u.str.data = dec_size + smp_trash->data;
1948 smp->data.u.str.area = smp_trash->area;
1949 smp->data.type = SMP_T_BIN;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001950 smp_dup(smp);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001951 free_trash_chunk(smp_trash_alloc);
Dragan Dosen9e8db132021-02-22 10:03:53 +01001952 free_trash_chunk(smp_trash);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001953 return 1;
1954
1955err:
1956 free_trash_chunk(smp_trash_alloc);
Dragan Dosen9e8db132021-02-22 10:03:53 +01001957 free_trash_chunk(smp_trash);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001958 return 0;
1959}
Ilya Shipitsin2c481d02021-03-26 23:35:31 +05001960#endif
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001961
Patrick Gansterer8e366512020-04-22 16:47:57 +02001962static int check_crypto_digest(struct arg *args, struct sample_conv *conv,
1963 const char *file, int line, char **err)
1964{
1965 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1966
1967 if (evp)
1968 return 1;
1969
1970 memprintf(err, "algorithm must be a valid OpenSSL message digest name.");
1971 return 0;
1972}
1973
1974static int sample_conv_crypto_digest(const struct arg *args, struct sample *smp, void *private)
1975{
1976 struct buffer *trash = get_trash_chunk();
1977 unsigned char *md = (unsigned char*) trash->area;
1978 unsigned int md_len = trash->size;
1979 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
1980 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1981
1982 if (!ctx)
1983 return 0;
1984
1985 if (!EVP_DigestInit_ex(ctx, evp, NULL) ||
1986 !EVP_DigestUpdate(ctx, smp->data.u.str.area, smp->data.u.str.data) ||
1987 !EVP_DigestFinal_ex(ctx, md, &md_len)) {
1988 EVP_MD_CTX_free(ctx);
1989 return 0;
1990 }
1991
1992 EVP_MD_CTX_free(ctx);
1993
1994 trash->data = md_len;
1995 smp->data.u.str = *trash;
1996 smp->data.type = SMP_T_BIN;
1997 smp->flags &= ~SMP_F_CONST;
1998 return 1;
1999}
2000
2001static int check_crypto_hmac(struct arg *args, struct sample_conv *conv,
2002 const char *file, int line, char **err)
2003{
2004 if (!check_crypto_digest(args, conv, file, line, err))
2005 return 0;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002006
2007 if (!sample_check_arg_base64(&args[1], err)) {
2008 memprintf(err, "failed to parse key : %s", *err);
2009 return 0;
2010 }
Patrick Gansterer8e366512020-04-22 16:47:57 +02002011
Patrick Gansterer8e366512020-04-22 16:47:57 +02002012 return 1;
2013}
2014
2015static int sample_conv_crypto_hmac(const struct arg *args, struct sample *smp, void *private)
2016{
2017 struct sample key;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002018 struct buffer *trash = NULL, *key_trash = NULL;
Patrick Gansterer8e366512020-04-22 16:47:57 +02002019 unsigned char *md;
2020 unsigned int md_len;
2021 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
2022 int dec_size;
2023
2024 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
2025 if (!sample_conv_var2smp_str(&args[1], &key))
2026 return 0;
2027
Dragan Dosen9e8db132021-02-22 10:03:53 +01002028 if (args[1].type == ARGT_VAR) {
2029 key_trash = alloc_trash_chunk();
2030 if (!key_trash)
2031 goto err;
2032
2033 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, key_trash->area, key_trash->size);
2034 if (dec_size < 0)
2035 goto err;
2036 key_trash->data = dec_size;
2037 key.data.u.str = *key_trash;
2038 }
Patrick Gansterer8e366512020-04-22 16:47:57 +02002039
Dragan Dosen9e8db132021-02-22 10:03:53 +01002040 trash = alloc_trash_chunk();
2041 if (!trash)
Patrick Gansterer8e366512020-04-22 16:47:57 +02002042 goto err;
2043
2044 md = (unsigned char*) trash->area;
2045 md_len = trash->size;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002046 if (!HMAC(evp, key.data.u.str.area, key.data.u.str.data, (const unsigned char*) smp->data.u.str.area,
2047 smp->data.u.str.data, md, &md_len))
Patrick Gansterer8e366512020-04-22 16:47:57 +02002048 goto err;
2049
2050 free_trash_chunk(key_trash);
2051
2052 trash->data = md_len;
2053 smp->data.u.str = *trash;
2054 smp->data.type = SMP_T_BIN;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002055 smp_dup(smp);
2056 free_trash_chunk(trash);
Patrick Gansterer8e366512020-04-22 16:47:57 +02002057 return 1;
2058
2059err:
2060 free_trash_chunk(key_trash);
Dragan Dosen9e8db132021-02-22 10:03:53 +01002061 free_trash_chunk(trash);
Patrick Gansterer8e366512020-04-22 16:47:57 +02002062 return 0;
2063}
2064
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02002065#endif /* USE_OPENSSL */
Tim Duesterhusd4376302019-06-17 12:41:44 +02002066
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002067static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002068{
Willy Tarreau83061a82018-07-13 11:56:34 +02002069 struct buffer *trash = get_trash_chunk();
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002070 unsigned char c;
2071 int ptr = 0;
2072
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002073 trash->data = 0;
2074 while (ptr < smp->data.u.str.data && trash->data <= trash->size - 2) {
2075 c = smp->data.u.str.area[ptr++];
2076 trash->area[trash->data++] = hextab[(c >> 4) & 0xF];
2077 trash->area[trash->data++] = hextab[c & 0xF];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002078 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002079 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002080 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002081 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002082 return 1;
2083}
2084
Dragan Dosen3f957b22017-10-24 09:27:34 +02002085static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
2086{
2087 long long int n = 0;
2088 int i, c;
2089
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002090 for (i = 0; i < smp->data.u.str.data; i++) {
2091 if ((c = hex2i(smp->data.u.str.area[i])) < 0)
Dragan Dosen3f957b22017-10-24 09:27:34 +02002092 return 0;
2093 n = (n << 4) + c;
2094 }
2095
2096 smp->data.u.sint = n;
2097 smp->data.type = SMP_T_SINT;
2098 smp->flags &= ~SMP_F_CONST;
2099 return 1;
2100}
2101
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002102/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002103static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002104{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002105 smp->data.u.sint = hash_djb2(smp->data.u.str.area,
2106 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002107 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002108 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002109 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002110 return 1;
2111}
2112
Willy Tarreau60a2ee72017-12-15 07:13:48 +01002113static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01002114{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002115 int i = smp->data.u.str.data;
Etienne Carriereed0d24e2017-12-13 13:41:34 +01002116 smp->data.u.sint = i;
2117 smp->data.type = SMP_T_SINT;
2118 return 1;
2119}
2120
2121
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002122static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01002123{
2124 int i;
2125
Willy Tarreauf0645dc2016-08-09 14:29:38 +02002126 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002127 return 0;
2128
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002129 for (i = 0; i < smp->data.u.str.data; i++) {
2130 if ((smp->data.u.str.area[i] >= 'A') && (smp->data.u.str.area[i] <= 'Z'))
2131 smp->data.u.str.area[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01002132 }
2133 return 1;
2134}
2135
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002136static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01002137{
2138 int i;
2139
Willy Tarreauf0645dc2016-08-09 14:29:38 +02002140 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02002141 return 0;
2142
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002143 for (i = 0; i < smp->data.u.str.data; i++) {
2144 if ((smp->data.u.str.area[i] >= 'a') && (smp->data.u.str.area[i] <= 'z'))
2145 smp->data.u.str.area[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01002146 }
2147 return 1;
2148}
2149
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002150/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
2151static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01002152{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002153 /* Attempt to convert to IPv4 to apply the correct mask. */
2154 c_ipv62ip(smp);
2155
2156 if (smp->data.type == SMP_T_IPV4) {
2157 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
2158 smp->data.type = SMP_T_IPV4;
2159 }
2160 else if (smp->data.type == SMP_T_IPV6) {
2161 /* IPv6 cannot be converted without an IPv6 mask. */
2162 if (args[1].type != ARGT_IPV6)
2163 return 0;
2164
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +01002165 write_u64(&smp->data.u.ipv6.s6_addr[0],
2166 read_u64(&smp->data.u.ipv6.s6_addr[0]) & read_u64(&args[1].data.ipv6.s6_addr[0]));
2167 write_u64(&smp->data.u.ipv6.s6_addr[8],
2168 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 +01002169 smp->data.type = SMP_T_IPV6;
2170 }
2171
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01002172 return 1;
2173}
2174
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002175/* takes an UINT value on input supposed to represent the time since EPOCH,
2176 * adds an optional offset found in args[1] and emits a string representing
2177 * the local time in the format specified in args[1] using strftime().
2178 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002179static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002180{
Willy Tarreau83061a82018-07-13 11:56:34 +02002181 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002182 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002183 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002184 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002185
2186 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002187 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002188 curr_date += args[1].data.sint;
2189
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002190 tm = localtime(&curr_date);
2191 if (!tm)
2192 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002193 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002194 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2195 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002196 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002197 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002198 return 1;
2199}
2200
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002201/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002202static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002203{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002204 smp->data.u.sint = hash_sdbm(smp->data.u.str.area,
2205 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002206 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002207 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002208 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002209 return 1;
2210}
2211
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002212/* takes an UINT value on input supposed to represent the time since EPOCH,
2213 * adds an optional offset found in args[1] and emits a string representing
2214 * the UTC date in the format specified in args[1] using strftime().
2215 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002216static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002217{
Willy Tarreau83061a82018-07-13 11:56:34 +02002218 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002219 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002220 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002221 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002222
2223 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002224 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002225 curr_date += args[1].data.sint;
2226
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002227 tm = gmtime(&curr_date);
2228 if (!tm)
2229 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002230 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002231 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2232 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002233 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002234 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002235 return 1;
2236}
2237
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002238/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002239static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002240{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002241 smp->data.u.sint = hash_wt6(smp->data.u.str.area,
2242 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002243 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002244 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002245 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002246 return 1;
2247}
2248
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002249/* hashes the binary input into a 32-bit unsigned int using xxh.
2250 * The seed of the hash defaults to 0 but can be changd in argument 1.
2251 */
2252static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
2253{
2254 unsigned int seed;
2255
Christopher Faulete6e7a582021-01-29 11:29:28 +01002256 if (arg_p->data.sint)
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002257 seed = arg_p->data.sint;
2258 else
2259 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002260 smp->data.u.sint = XXH32(smp->data.u.str.area, smp->data.u.str.data,
2261 seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002262 smp->data.type = SMP_T_SINT;
2263 return 1;
2264}
2265
2266/* hashes the binary input into a 64-bit unsigned int using xxh.
2267 * In fact, the function returns a 64 bit unsigned, but the sample
2268 * storage of haproxy only proposes 64-bits signed, so the value is
2269 * cast as signed. This cast doesn't impact the hash repartition.
2270 * The seed of the hash defaults to 0 but can be changd in argument 1.
2271 */
2272static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
2273{
2274 unsigned long long int seed;
2275
Christopher Faulete6e7a582021-01-29 11:29:28 +01002276 if (arg_p->data.sint)
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002277 seed = (unsigned long long int)arg_p->data.sint;
2278 else
2279 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002280 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.area,
2281 smp->data.u.str.data, seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002282 smp->data.type = SMP_T_SINT;
2283 return 1;
2284}
2285
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01002286static int sample_conv_xxh3(const struct arg *arg_p, struct sample *smp, void *private)
2287{
2288 unsigned long long int seed;
2289
Christopher Faulete6e7a582021-01-29 11:29:28 +01002290 if (arg_p->data.sint)
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01002291 seed = (unsigned long long int)arg_p->data.sint;
2292 else
2293 seed = 0;
2294 smp->data.u.sint = (long long int)XXH3(smp->data.u.str.area,
2295 smp->data.u.str.data, seed);
2296 smp->data.type = SMP_T_SINT;
2297 return 1;
2298}
2299
Willy Tarreau80599772015-01-20 19:35:24 +01002300/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002301static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002302{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002303 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2304 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002305 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002306 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002307 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002308 return 1;
2309}
2310
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002311/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2312static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2313{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002314 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2315 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002316 if (arg_p->data.sint)
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002317 smp->data.u.sint = full_hash(smp->data.u.sint);
2318 smp->data.type = SMP_T_SINT;
2319 return 1;
2320}
2321
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002322/* This function escape special json characters. The returned string can be
2323 * safely set between two '"' and used as json string. The json string is
2324 * defined like this:
2325 *
2326 * any Unicode character except '"' or '\' or control character
2327 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2328 *
2329 * The enum input_type contain all the allowed mode for decoding the input
2330 * string.
2331 */
2332enum input_type {
2333 IT_ASCII = 0,
2334 IT_UTF8,
2335 IT_UTF8S,
2336 IT_UTF8P,
2337 IT_UTF8PS,
2338};
William Dauchy5417e892021-01-08 21:57:41 +01002339
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002340static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2341 const char *file, int line, char **err)
2342{
Christopher Faulet95917132020-08-05 23:07:07 +02002343 enum input_type type;
2344
Christopher Faulet95917132020-08-05 23:07:07 +02002345 if (strcmp(arg->data.str.area, "") == 0)
2346 type = IT_ASCII;
2347 else if (strcmp(arg->data.str.area, "ascii") == 0)
2348 type = IT_ASCII;
2349 else if (strcmp(arg->data.str.area, "utf8") == 0)
2350 type = IT_UTF8;
2351 else if (strcmp(arg->data.str.area, "utf8s") == 0)
2352 type = IT_UTF8S;
2353 else if (strcmp(arg->data.str.area, "utf8p") == 0)
2354 type = IT_UTF8P;
2355 else if (strcmp(arg->data.str.area, "utf8ps") == 0)
2356 type = IT_UTF8PS;
2357 else {
2358 memprintf(err, "Unexpected input code type. "
2359 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
2360 return 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002361 }
2362
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002363 chunk_destroy(&arg->data.str);
Christopher Faulet95917132020-08-05 23:07:07 +02002364 arg->type = ARGT_SINT;
2365 arg->data.sint = type;
2366 return 1;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002367}
2368
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002369static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002370{
Willy Tarreau83061a82018-07-13 11:56:34 +02002371 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002372 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2373 const char *str;
2374 int len;
2375 enum input_type input_type = IT_ASCII;
2376 unsigned int c;
2377 unsigned int ret;
2378 char *p;
2379
Christopher Faulete6e7a582021-01-29 11:29:28 +01002380 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002381
2382 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002383 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002384
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002385 p = smp->data.u.str.area;
2386 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002387
2388 if (input_type == IT_ASCII) {
2389 /* Read input as ASCII. */
2390 c = *(unsigned char *)p;
2391 p++;
2392 }
2393 else {
2394 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002395 ret = utf8_next(p,
2396 smp->data.u.str.data - ( p - smp->data.u.str.area),
2397 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002398 p += utf8_return_length(ret);
2399
2400 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2401 return 0;
2402 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2403 continue;
2404 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2405 return 0;
2406 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2407 continue;
2408
2409 /* Check too big values. */
2410 if ((unsigned int)c > 0xffff) {
2411 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2412 return 0;
2413 continue;
2414 }
2415 }
2416
2417 /* Convert character. */
2418 if (c == '"') {
2419 len = 2;
2420 str = "\\\"";
2421 }
2422 else if (c == '\\') {
2423 len = 2;
2424 str = "\\\\";
2425 }
2426 else if (c == '/') {
2427 len = 2;
2428 str = "\\/";
2429 }
2430 else if (c == '\b') {
2431 len = 2;
2432 str = "\\b";
2433 }
2434 else if (c == '\f') {
2435 len = 2;
2436 str = "\\f";
2437 }
2438 else if (c == '\r') {
2439 len = 2;
2440 str = "\\r";
2441 }
2442 else if (c == '\n') {
2443 len = 2;
2444 str = "\\n";
2445 }
2446 else if (c == '\t') {
2447 len = 2;
2448 str = "\\t";
2449 }
Willy Tarreau90807112020-02-25 08:16:33 +01002450 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002451 /* isprint generate a segfault if c is too big. The man says that
2452 * c must have the value of an unsigned char or EOF.
2453 */
2454 len = 6;
2455 _str[0] = '\\';
2456 _str[1] = 'u';
2457 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2458 str = _str;
2459 }
2460 else {
2461 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002462 _str[0] = c;
2463 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002464 }
2465
2466 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002467 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002468 return 0;
2469
2470 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002471 memcpy(temp->area + temp->data, str, len);
2472 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002473 }
2474
2475 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002476 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002477 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002478
2479 return 1;
2480}
2481
Emeric Brun54c4ac82014-11-03 15:32:43 +01002482/* This sample function is designed to extract some bytes from an input buffer.
2483 * First arg is the offset.
2484 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002485static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002486{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002487 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2488 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002489 return 1;
2490 }
2491
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002492 if (smp->data.u.str.size)
2493 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002494 smp->data.u.str.data -= arg_p[0].data.sint;
2495 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002496
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002497 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2498 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002499
2500 return 1;
2501}
2502
Emeric Brunf399b0d2014-11-03 17:07:03 +01002503static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2504 const char *file, int line, char **err)
2505{
2506 struct arg *arg = args;
2507
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002508 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002509 memprintf(err, "Unexpected arg type");
2510 return 0;
2511 }
2512
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002513 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002514 memprintf(err, "Unexpected value 0 for index");
2515 return 0;
2516 }
2517
2518 arg++;
2519
2520 if (arg->type != ARGT_STR) {
2521 memprintf(err, "Unexpected arg type");
2522 return 0;
2523 }
2524
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002525 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002526 memprintf(err, "Empty separators list");
2527 return 0;
2528 }
2529
2530 return 1;
2531}
2532
2533/* This sample function is designed to a return selected part of a string (field).
2534 * First arg is the index of the field (start at 1)
2535 * Second arg is a char list of separators (type string)
2536 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002537static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002538{
Marcin Deranek9631a282018-04-16 14:30:46 +02002539 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002540 char *start, *end;
2541 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002542 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002543
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002544 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002545 return 0;
2546
Marcin Deranek9631a282018-04-16 14:30:46 +02002547 if (arg_p[0].data.sint < 0) {
2548 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002549 end = start = smp->data.u.str.area + smp->data.u.str.data;
2550 while (start > smp->data.u.str.area) {
2551 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2552 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002553 if (field == arg_p[0].data.sint) {
2554 if (count == 1)
2555 goto found;
2556 else if (count > 1)
2557 count--;
2558 } else {
2559 end = start-1;
2560 field--;
2561 }
2562 break;
2563 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002564 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002565 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002566 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002567 } else {
2568 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002569 end = start = smp->data.u.str.area;
2570 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2571 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2572 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002573 if (field == arg_p[0].data.sint) {
2574 if (count == 1)
2575 goto found;
2576 else if (count > 1)
2577 count--;
2578 } else {
2579 start = end+1;
2580 field++;
2581 }
2582 break;
2583 }
2584 }
2585 end++;
2586 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002587 }
2588
2589 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002590 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002591 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002592 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002593 }
2594found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002595 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002596 /* If ret string is len 0, no need to
2597 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002598 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002599 return 1;
2600
Emeric Brunf399b0d2014-11-03 17:07:03 +01002601 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002602 Note: smp->data.u.str.size cannot be set to 0 */
2603 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002604 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002605
Thayne McCombsb2843052021-04-11 23:26:59 -06002606 smp->data.u.str.area = start;
2607
Emeric Brunf399b0d2014-11-03 17:07:03 +01002608 return 1;
2609}
2610
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002611/* This sample function is designed to return a word from a string.
2612 * First arg is the index of the word (start at 1)
2613 * Second arg is a char list of words separators (type string)
2614 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002615static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002616{
Marcin Deranek9631a282018-04-16 14:30:46 +02002617 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002618 char *start, *end;
2619 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002620 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002621
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002622 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002623 return 0;
2624
2625 word = 0;
2626 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002627 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002628 end = start = smp->data.u.str.area + smp->data.u.str.data;
2629 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002630 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002631 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2632 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002633 issep = 1;
2634 break;
2635 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002636 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002637 if (!inword) {
2638 if (!issep) {
2639 if (word != arg_p[0].data.sint) {
2640 word--;
2641 end = start;
2642 }
2643 inword = 1;
2644 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002645 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002646 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002647 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002648 if (count == 1)
2649 goto found;
2650 else if (count > 1)
2651 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002652 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002653 inword = 0;
2654 }
2655 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002656 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002657 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002658 end = start = smp->data.u.str.area;
2659 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002660 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002661 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2662 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002663 issep = 1;
2664 break;
2665 }
2666 }
2667 if (!inword) {
2668 if (!issep) {
2669 if (word != arg_p[0].data.sint) {
2670 word++;
2671 start = end;
2672 }
2673 inword = 1;
2674 }
2675 }
2676 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002677 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002678 if (count == 1)
2679 goto found;
2680 else if (count > 1)
2681 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002682 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002683 inword = 0;
2684 }
2685 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002686 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002687 }
2688
2689 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002690 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002691 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002692 return 1;
2693 }
2694found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002695 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002696 /* If ret string is len 0, no need to
2697 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002698 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002699 return 1;
2700
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002701 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002702
2703 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002704 Note: smp->data.u.str.size cannot be set to 0 */
2705 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002706 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002707
2708 return 1;
2709}
2710
Willy Tarreau7eda8492015-01-20 19:47:06 +01002711static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2712 const char *file, int line, char **err)
2713{
2714 struct arg *arg = args;
2715 char *p;
2716 int len;
2717
2718 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2719 arg[0].type_flags = 0;
2720
2721 if (arg[2].type != ARGT_STR)
2722 return 1;
2723
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002724 p = arg[2].data.str.area;
2725 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002726 while (len) {
2727 if (*p == 'i') {
2728 arg[0].type_flags |= ARGF_REG_ICASE;
2729 }
2730 else if (*p == 'g') {
2731 arg[0].type_flags |= ARGF_REG_GLOB;
2732 }
2733 else {
2734 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2735 return 0;
2736 }
2737 p++;
2738 len--;
2739 }
2740 return 1;
2741}
2742
2743/* This sample function is designed to do the equivalent of s/match/replace/ on
2744 * the input string. It applies a regex and restarts from the last matched
2745 * location until nothing matches anymore. First arg is the regex to apply to
2746 * the input string, second arg is the replacement expression.
2747 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002748static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002749{
2750 char *start, *end;
2751 struct my_regex *reg = arg_p[0].data.reg;
2752 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002753 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002754 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002755 int flag, max;
2756 int found;
2757
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002758 start = smp->data.u.str.area;
2759 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002760
2761 flag = 0;
2762 while (1) {
2763 /* check for last round which is used to copy remaining parts
2764 * when not running in global replacement mode.
2765 */
2766 found = 0;
2767 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2768 /* Note: we can have start == end on empty strings or at the end */
2769 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2770 }
2771
2772 if (!found)
2773 pmatch[0].rm_so = end - start;
2774
2775 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002776 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002777 if (max && pmatch[0].rm_so > 0) {
2778 if (max > pmatch[0].rm_so)
2779 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002780 memcpy(trash->area + trash->data, start, max);
2781 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002782 }
2783
2784 if (!found)
2785 break;
2786
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002787 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002788 if (!output)
2789 break;
2790
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002791 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2792
Willy Tarreau7eda8492015-01-20 19:47:06 +01002793 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002794 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002795 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002796 if (max > output->data)
2797 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002798 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002799 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002800 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002801 }
2802
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002803 free_trash_chunk(output);
2804
Willy Tarreau7eda8492015-01-20 19:47:06 +01002805 /* stop here if we're done with this string */
2806 if (start >= end)
2807 break;
2808
2809 /* We have a special case for matches of length 0 (eg: "x*y*").
2810 * These ones are considered to match in front of a character,
2811 * so we have to copy that character and skip to the next one.
2812 */
2813 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002814 if (trash->data < trash->size)
2815 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002816 pmatch[0].rm_eo++;
2817 }
2818
2819 start += pmatch[0].rm_eo;
2820 flag |= REG_NOTBOL;
2821 }
2822
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002823 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002824 return 1;
2825}
2826
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002827/* This function check an operator entry. It expects a string.
2828 * The string can be an integer or a variable name.
2829 */
2830static int check_operator(struct arg *args, struct sample_conv *conv,
2831 const char *file, int line, char **err)
2832{
2833 const char *str;
2834 const char *end;
Christopher Faulet95917132020-08-05 23:07:07 +02002835 long long int i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002836
2837 /* Try to decode a variable. */
2838 if (vars_check_arg(&args[0], NULL))
2839 return 1;
2840
2841 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002842 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002843 end = str + strlen(str);
Christopher Faulet95917132020-08-05 23:07:07 +02002844 i = read_int64(&str, end);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002845 if (*str != '\0') {
2846 memprintf(err, "expects an integer or a variable name");
2847 return 0;
2848 }
Christopher Faulet95917132020-08-05 23:07:07 +02002849
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002850 chunk_destroy(&args[0].data.str);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002851 args[0].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02002852 args[0].data.sint = i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002853 return 1;
2854}
2855
Willy Tarreau6204cd92016-03-10 16:33:04 +01002856/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002857 * If the arg contain an integer, the integer is returned in the
2858 * sample. If the arg contains a variable descriptor, it returns the
2859 * variable value.
2860 *
2861 * This function returns 0 if an error occurs, otherwise it returns 1.
2862 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002863static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002864{
2865 switch (arg->type) {
2866 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002867 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002868 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002869 return 1;
2870 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002871 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002872 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002873 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002874 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002875 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002876 return 0;
2877 return 1;
2878 default:
2879 return 0;
2880 }
2881}
2882
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002883/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002884 * result.
2885 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002886static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002887{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002888 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002889 return 1;
2890}
2891
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002892/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002893 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002894 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002895static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002896{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002897 struct sample tmp;
2898
Willy Tarreau7560dd42016-03-10 16:28:58 +01002899 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002900 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002901 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002902 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002903 return 1;
2904}
2905
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002906/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002907 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002908 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002909static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002910{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002911 struct sample tmp;
2912
Willy Tarreau7560dd42016-03-10 16:28:58 +01002913 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002914 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002915 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002916 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002917 return 1;
2918}
2919
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002920/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002921 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002922 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002923static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002924{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002925 struct sample tmp;
2926
Willy Tarreau7560dd42016-03-10 16:28:58 +01002927 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002928 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002929 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002930 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002931 return 1;
2932}
2933
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002934static inline long long int arith_add(long long int a, long long int b)
2935{
2936 /* Prevent overflow and makes capped calculus.
2937 * We must ensure that the check calculus doesn't
2938 * exceed the signed 64 bits limits.
2939 *
2940 * +----------+----------+
2941 * | a<0 | a>=0 |
2942 * +------+----------+----------+
2943 * | b<0 | MIN-a>b | no check |
2944 * +------+----------+----------+
2945 * | b>=0 | no check | MAX-a<b |
2946 * +------+----------+----------+
2947 */
2948 if ((a ^ b) >= 0) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002949 /* signs are different. */
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002950 if (a < 0) {
2951 if (LLONG_MIN - a > b)
2952 return LLONG_MIN;
2953 }
2954 if (LLONG_MAX - a < b)
2955 return LLONG_MAX;
2956 }
2957 return a + b;
2958}
2959
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002960/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002961 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002962 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002963static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002964{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002965 struct sample tmp;
2966
Willy Tarreau7560dd42016-03-10 16:28:58 +01002967 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002968 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002969 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002970 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002971 return 1;
2972}
2973
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002974/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002975 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002976 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002977static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002978 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002979{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002980 struct sample tmp;
2981
Willy Tarreau7560dd42016-03-10 16:28:58 +01002982 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002983 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002984 return 0;
2985
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002986 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2987 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2988 * of -LLONG_MIN and correct the result.
2989 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002990 if (tmp.data.u.sint == LLONG_MIN) {
2991 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2992 if (smp->data.u.sint < LLONG_MAX)
2993 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002994 return 1;
2995 }
2996
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002997 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002998 * the second operand.
2999 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003000 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01003001 return 1;
3002}
3003
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003004/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003005 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003006 * If the result makes an overflow, then the largest possible quantity is
3007 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003008 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003009static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003010 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003011{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003012 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003013 long long int c;
3014
Willy Tarreau7560dd42016-03-10 16:28:58 +01003015 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01003016 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003017 return 0;
3018
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003019 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003020 if (!smp->data.u.sint || !tmp.data.u.sint) {
3021 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003022 return 1;
3023 }
3024
3025 /* The multiply between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003026 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003027 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003028 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3029 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003030 return 1;
3031 }
3032
3033 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003034 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003035
3036 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003037 if (smp->data.u.sint != c / tmp.data.u.sint) {
3038 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
3039 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003040 return 1;
3041 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003042 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003043 return 1;
3044 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003045 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01003046 return 1;
3047}
3048
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003049/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003050 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003051 * If arg_p makes the result overflow, then the largest possible quantity is
3052 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003053 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003054static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003055 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003056{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003057 struct sample tmp;
3058
Willy Tarreau7560dd42016-03-10 16:28:58 +01003059 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01003060 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003061 return 0;
3062
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003063 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003064 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003065 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003066 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003067 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3068 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003069 return 1;
3070 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003071 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003072 return 1;
3073 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003074 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01003075 return 1;
3076}
3077
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003078/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003079 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003080 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003081 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003082static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003083 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003084{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003085 struct sample tmp;
3086
Willy Tarreau7560dd42016-03-10 16:28:58 +01003087 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01003088 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003089 return 0;
3090
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003091 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003092 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003093 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003094 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003095 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3096 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003097 return 1;
3098 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003099 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003100 return 1;
3101 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003102 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01003103 return 1;
3104}
3105
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003106/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01003107 * result.
3108 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003109static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003110 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003111{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003112 if (smp->data.u.sint == LLONG_MIN)
3113 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003114 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003115 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01003116 return 1;
3117}
3118
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003119/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01003120 * false. The output is a BOOL.
3121 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003122static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003123 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003124{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003125 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003126 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003127 return 1;
3128}
3129
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003130/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01003131 * truee. The output is a BOOL.
3132 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003133static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003134 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003135{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003136 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003137 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003138 return 1;
3139}
3140
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003141/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01003142 * The output is a BOOL.
3143 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003144static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003145 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003146{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003147 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003148 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003149 return 1;
3150}
3151
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003152/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01003153 * The output is a BOOL.
3154 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003155static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003156 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003157{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003158 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003159 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003160 return 1;
3161}
3162
Willy Tarreau280f42b2018-02-19 15:34:12 +01003163/* appends an optional const string, an optional variable contents and another
3164 * optional const string to an existing string.
3165 */
3166static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
3167{
Willy Tarreau83061a82018-07-13 11:56:34 +02003168 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003169 struct sample tmp;
3170 int max;
3171
Willy Tarreau591fc3a2021-01-08 16:08:43 +01003172 trash = alloc_trash_chunk();
William Dauchye9970102021-01-11 11:05:58 +01003173 if (!trash)
3174 return 0;
3175
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003176 trash->data = smp->data.u.str.data;
3177 if (trash->data > trash->size - 1)
3178 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003179
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003180 memcpy(trash->area, smp->data.u.str.area, trash->data);
3181 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003182
3183 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003184 max = arg_p[0].data.str.data;
3185 if (max > trash->size - 1 - trash->data)
3186 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003187
3188 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003189 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3190 trash->data += max;
3191 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003192 }
3193
3194 /* append second string (variable) if it's found and we can turn it
3195 * into a string.
3196 */
3197 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3198 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3199 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3200 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3201
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003202 max = tmp.data.u.str.data;
3203 if (max > trash->size - 1 - trash->data)
3204 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003205
3206 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003207 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3208 max);
3209 trash->data += max;
3210 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003211 }
3212 }
3213
3214 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003215 max = arg_p[2].data.str.data;
3216 if (max > trash->size - 1 - trash->data)
3217 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003218
3219 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003220 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3221 trash->data += max;
3222 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003223 }
3224
3225 smp->data.u.str = *trash;
3226 smp->data.type = SMP_T_STR;
Willy Tarreau591fc3a2021-01-08 16:08:43 +01003227 smp_dup(smp);
3228 free_trash_chunk(trash);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003229 return 1;
3230}
3231
3232/* This function checks the "concat" converter's arguments and extracts the
3233 * variable name and its scope.
3234 */
3235static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3236 const char *file, int line, char **err)
3237{
3238 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003239 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3240 memprintf(err, "failed to register variable name '%s'",
3241 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003242 return 0;
3243 }
3244 return 1;
3245}
3246
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003247/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003248 * is compatible with strcmp(3)'s return value.
3249 */
3250static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3251{
3252 struct sample tmp;
3253 int max, result;
3254
3255 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3256 if (arg_p[0].type != ARGT_VAR)
3257 return 0;
3258 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3259 return 0;
3260 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3261 return 0;
3262
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003263 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3264 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003265 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003266 if (smp->data.u.str.data != tmp.data.u.str.data) {
3267 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003268 result = -1;
3269 }
3270 else {
3271 result = 1;
3272 }
3273 }
3274 }
3275
3276 smp->data.u.sint = result;
3277 smp->data.type = SMP_T_SINT;
3278 return 1;
3279}
3280
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003281#ifdef USE_OPENSSL
3282/* Compares bytestring with a variable containing a bytestring. Return value
3283 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3284 *
3285 * Comparison will be performed in constant time if both bytestrings are of
3286 * the same length. If the lengths differ execution time will not be constant.
3287 */
3288static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3289{
3290 struct sample tmp;
3291 int result;
3292
3293 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3294 if (arg_p[0].type != ARGT_VAR)
3295 return 0;
3296 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3297 return 0;
3298 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3299 return 0;
3300
3301 if (smp->data.u.str.data != tmp.data.u.str.data) {
3302 smp->data.u.sint = 0;
3303 smp->data.type = SMP_T_BOOL;
3304 return 1;
3305 }
3306
3307 /* The following comparison is performed in constant time. */
3308 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3309
3310 smp->data.u.sint = result == 0;
3311 smp->data.type = SMP_T_BOOL;
3312 return 1;
3313}
3314#endif
3315
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02003316/* Takes a boolean as input. Returns the first argument if that boolean is true and
3317 * the second argument otherwise.
3318 */
3319static int sample_conv_iif(const struct arg *arg_p, struct sample *smp, void *private)
3320{
3321 smp->data.type = SMP_T_STR;
3322 smp->flags |= SMP_F_CONST;
3323
3324 if (smp->data.u.sint) {
3325 smp->data.u.str.data = arg_p[0].data.str.data;
3326 smp->data.u.str.area = arg_p[0].data.str.area;
3327 }
3328 else {
3329 smp->data.u.str.data = arg_p[1].data.str.data;
3330 smp->data.u.str.area = arg_p[1].data.str.area;
3331 }
3332
3333 return 1;
3334}
3335
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003336#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3337#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3338#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3339
3340/*
3341 * Extract the field value of an input binary sample. Takes a mandatory argument:
3342 * the protocol buffers field identifier (dotted notation) internally represented
3343 * as an array of unsigned integers and its size.
3344 * Return 1 if the field was found, 0 if not.
3345 */
3346static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3347{
3348 unsigned char *pos;
3349 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003350
3351 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003352 grpc_left = smp->data.u.str.data;
3353
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003354 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003355 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003356
3357 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3358
3359 pos += GRPC_MSG_HEADER_SZ;
3360 grpc_left -= GRPC_MSG_HEADER_SZ;
3361
3362 if (grpc_left < left)
3363 return 0;
3364
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003365 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3366 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003367
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003368 grpc_left -= grpc_msg_len;
3369 }
3370
3371 return 0;
3372}
3373
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003374static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3375{
3376 unsigned char *pos;
3377 size_t left;
3378
3379 pos = (unsigned char *)smp->data.u.str.area;
3380 left = smp->data.u.str.data;
3381
3382 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3383}
3384
3385static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3386 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003387{
3388 if (!args[1].type) {
3389 args[1].type = ARGT_SINT;
3390 args[1].data.sint = PBUF_T_BINARY;
3391 }
3392 else {
3393 int pbuf_type;
3394
3395 pbuf_type = protobuf_type(args[1].data.str.area);
3396 if (pbuf_type == -1) {
3397 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3398 return 0;
3399 }
3400
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003401 chunk_destroy(&args[1].data.str);
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003402 args[1].type = ARGT_SINT;
3403 args[1].data.sint = pbuf_type;
3404 }
3405
3406 return 1;
3407}
3408
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003409/*
3410 * Extract the tag value of an input binary sample. Takes a mandatory argument:
3411 * the FIX protocol tag identifier.
3412 * Return 1 if the tag was found, 0 if not.
3413 */
3414static int sample_conv_fix_tag_value(const struct arg *arg_p, struct sample *smp, void *private)
3415{
3416 struct ist value;
3417
3418 smp->flags &= ~SMP_F_MAY_CHANGE;
3419 value = fix_tag_value(ist2(smp->data.u.str.area, smp->data.u.str.data),
3420 arg_p[0].data.sint);
3421 if (!istlen(value)) {
3422 if (!isttest(value)) {
3423 /* value != IST_NULL, need more data */
3424 smp->flags |= SMP_F_MAY_CHANGE;
3425 }
3426 return 0;
3427 }
3428
3429 smp->data.u.str = ist2buf(value);
3430 smp->flags |= SMP_F_CONST;
3431
3432 return 1;
3433}
3434
3435/* This function checks the "fix_tag_value" converter configuration.
3436 * It expects a "known" (by HAProxy) tag name or ID.
3437 * Tag string names are converted to their ID counterpart because this is the
3438 * format they are sent over the wire.
3439 */
3440static int sample_conv_fix_value_check(struct arg *args, struct sample_conv *conv,
3441 const char *file, int line, char **err)
3442{
3443 struct ist str;
3444 unsigned int tag;
3445
3446 str = ist2(args[0].data.str.area, args[0].data.str.data);
3447 tag = fix_tagid(str);
3448 if (!tag) {
3449 memprintf(err, "Unknown FIX tag name '%s'", args[0].data.str.area);
3450 return 0;
3451 }
3452
3453 chunk_destroy(&args[0].data.str);
3454 args[0].type = ARGT_SINT;
3455 args[0].data.sint = tag;
3456
3457 return 1;
3458}
3459
3460/*
3461 * Checks that a buffer contains a valid FIX message
3462 *
3463 * Return 1 if the check could be run, 0 if not.
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003464 * The result of the analyse itself is stored in <smp> as a boolean
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003465 */
3466static int sample_conv_fix_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3467{
3468 struct ist msg;
3469
3470 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3471
3472 smp->flags &= ~SMP_F_MAY_CHANGE;
3473 switch (fix_validate_message(msg)) {
3474 case FIX_VALID_MESSAGE:
3475 smp->data.type = SMP_T_BOOL;
3476 smp->data.u.sint = 1;
3477 return 1;
3478 case FIX_NEED_MORE_DATA:
3479 smp->flags |= SMP_F_MAY_CHANGE;
3480 return 0;
3481 case FIX_INVALID_MESSAGE:
3482 smp->data.type = SMP_T_BOOL;
3483 smp->data.u.sint = 0;
3484 return 1;
3485 }
3486 return 0;
3487}
3488
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003489/*
3490 * Extract the field value of an input binary sample containing an MQTT packet.
3491 * Takes 2 mandatory arguments:
3492 * - packet type
3493 * - field name
3494 *
3495 * return 1 if the field was found, 0 if not.
3496 */
3497static int sample_conv_mqtt_field_value(const struct arg *arg_p, struct sample *smp, void *private)
3498{
3499 struct ist pkt, value;
3500 int type, fieldname_id;
3501
3502 pkt = ist2(smp->data.u.str.area, smp->data.u.str.data);
3503 type = arg_p[0].data.sint;
3504 fieldname_id = arg_p[1].data.sint;
3505
3506 smp->flags &= ~SMP_F_MAY_CHANGE;
3507 value = mqtt_field_value(pkt, type, fieldname_id);
3508 if (!istlen(value)) {
3509 if (isttest(value)) {
3510 /* value != IST_NULL, need more data */
3511 smp->flags |= SMP_F_MAY_CHANGE;
3512 }
3513 return 0;
3514 }
3515
3516 smp->data.u.str = ist2buf(value);
3517 smp->flags |= SMP_F_CONST;
3518 return 1;
3519}
3520
3521/*
3522 * this function checks the "mqtt_field_value" converter configuration.
3523 * It expects a known packet type name or ID and a field name, in this order
3524 *
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003525 * Args[0] will be turned into a MQTT_CPT_* value for direct matching when parsing
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003526 * a packet.
3527 */
3528static int sample_conv_mqtt_field_value_check(struct arg *args, struct sample_conv *conv,
3529 const char *file, int line, char **err)
3530{
3531 int type, fieldname_id;
3532
3533 /* check the MQTT packet type is valid */
3534 type = mqtt_typeid(ist2(args[0].data.str.area, args[0].data.str.data));
3535 if (type == MQTT_CPT_INVALID) {
3536 memprintf(err, "Unknown MQTT type '%s'", args[0].data.str.area);
3537 return 0;
3538 }
3539
3540 /* check the field name belongs to the MQTT packet type */
3541 fieldname_id = mqtt_check_type_fieldname(type, ist2(args[1].data.str.area, args[1].data.str.data));
3542 if (fieldname_id == MQTT_FN_INVALID) {
3543 memprintf(err, "Unknown MQTT field name '%s' for packet type '%s'", args[1].data.str.area,
3544 args[0].data.str.area);
3545 return 0;
3546 }
3547
3548 /* save numeric counterparts of type and field name */
3549 chunk_destroy(&args[0].data.str);
3550 chunk_destroy(&args[1].data.str);
3551 args[0].type = ARGT_SINT;
3552 args[0].data.sint = type;
3553 args[1].type = ARGT_SINT;
3554 args[1].data.sint = fieldname_id;
3555
3556 return 1;
3557}
3558
3559/*
3560 * Checks that <smp> contains a valid MQTT message
3561 *
3562 * The function returns 1 if the check was run to its end, 0 otherwise.
3563 * The result of the analyse itself is stored in <smp> as a boolean.
3564 */
3565static int sample_conv_mqtt_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3566{
3567 struct ist msg;
3568
3569 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3570
3571 smp->flags &= ~SMP_F_MAY_CHANGE;
3572 switch (mqtt_validate_message(msg, NULL)) {
3573 case FIX_VALID_MESSAGE:
3574 smp->data.type = SMP_T_BOOL;
3575 smp->data.u.sint = 1;
3576 return 1;
3577 case FIX_NEED_MORE_DATA:
3578 smp->flags |= SMP_F_MAY_CHANGE;
3579 return 0;
3580 case FIX_INVALID_MESSAGE:
3581 smp->data.type = SMP_T_BOOL;
3582 smp->data.u.sint = 0;
3583 return 1;
3584 }
3585 return 0;
3586}
3587
Tim Duesterhusca097c12018-04-27 21:18:45 +02003588/* This function checks the "strcmp" converter's arguments and extracts the
3589 * variable name and its scope.
3590 */
3591static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3592 const char *file, int line, char **err)
3593{
Willy Tarreaua1169b62021-05-08 06:50:28 +02003594 if (!args[0].data.str.data) {
3595 memprintf(err, "missing variable name");
3596 return 0;
3597 }
3598
Tim Duesterhusca097c12018-04-27 21:18:45 +02003599 /* Try to decode a variable. */
3600 if (vars_check_arg(&args[0], NULL))
3601 return 1;
3602
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003603 memprintf(err, "failed to register variable name '%s'",
3604 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003605 return 0;
3606}
3607
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003608#ifdef USE_OPENSSL
3609/* This function checks the "secure_memcmp" converter's arguments and extracts the
3610 * variable name and its scope.
3611 */
3612static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3613 const char *file, int line, char **err)
3614{
Willy Tarreaua1169b62021-05-08 06:50:28 +02003615 if (!args[0].data.str.data) {
3616 memprintf(err, "missing variable name");
3617 return 0;
3618 }
3619
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003620 /* Try to decode a variable. */
3621 if (vars_check_arg(&args[0], NULL))
3622 return 1;
3623
3624 memprintf(err, "failed to register variable name '%s'",
3625 args[0].data.str.area);
3626 return 0;
3627}
3628#endif
3629
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003630/**/
3631static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3632{
3633 struct buffer *tmp;
3634 uint32_t n;
3635
3636 n = htonl((uint32_t)smp->data.u.sint);
3637 tmp = get_trash_chunk();
3638
3639 memcpy(b_head(tmp), &n, 4);
3640 b_add(tmp, 4);
3641
3642 smp->data.u.str = *tmp;
3643 smp->data.type = SMP_T_BIN;
3644 return 1;
3645}
3646
Christopher Fauletea159d62020-04-01 16:21:44 +02003647/**/
3648static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3649{
3650 char *p;
3651 size_t l;
3652
3653 p = smp->data.u.str.area;
3654 for (l = 0; l < smp->data.u.str.data; l++) {
3655 if (*(p+l) == '\r' || *(p+l) == '\n')
3656 break;
3657 }
3658 smp->data.u.str.data = l;
3659 return 1;
3660}
3661
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003662/**/
3663static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3664{
3665 char *delimiters, *p;
3666 size_t dlen, l;
3667
3668 delimiters = arg_p[0].data.str.area;
3669 dlen = arg_p[0].data.str.data;
3670
3671 l = smp->data.u.str.data;
3672 p = smp->data.u.str.area;
3673 while (l && memchr(delimiters, *p, dlen) != NULL) {
3674 p++;
3675 l--;
3676 }
3677
3678 smp->data.u.str.area = p;
3679 smp->data.u.str.data = l;
3680 return 1;
3681}
3682
Christopher Faulet568415a2020-04-01 17:24:47 +02003683/**/
3684static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3685{
3686 char *delimiters, *p;
3687 size_t dlen, l;
3688
3689 delimiters = arg_p[0].data.str.area;
3690 dlen = arg_p[0].data.str.data;
3691
3692 l = smp->data.u.str.data;
3693 p = smp->data.u.str.area + l - 1;
3694 while (l && memchr(delimiters, *p, dlen) != NULL) {
3695 p--;
3696 l--;
3697 }
3698
3699 smp->data.u.str.data = l;
3700 return 1;
3701}
3702
Alex51c8ad42021-04-15 16:45:15 +02003703/* This function checks the "json_query" converter's arguments. */
3704static int sample_check_json_query(struct arg *arg, struct sample_conv *conv,
3705 const char *file, int line, char **err)
3706{
3707 if (arg[0].data.str.data == 0) {
3708 memprintf(err, "json_path must not be empty");
3709 return 0;
3710 }
3711
3712 if (arg[1].data.str.data != 0) {
3713 if (strcmp(arg[1].data.str.area, "int") != 0) {
3714 memprintf(err, "output_type only supports \"int\" as argument");
3715 return 0;
3716 } else {
3717 arg[1].type = ARGT_SINT;
3718 arg[1].data.sint = 0;
3719 }
3720 }
3721 return 1;
3722}
3723
3724/* Limit JSON integer values to the range [-(2**53)+1, (2**53)-1] as per
3725 * the recommendation for interoperable integers in section 6 of RFC 7159.
3726 */
3727#define JSON_INT_MAX ((1LL << 53) - 1)
3728#define JSON_INT_MIN (-JSON_INT_MAX)
3729
3730/* This sample function get the value from a given json string.
3731 * The mjson library is used to parse the JSON struct
3732 */
3733static int sample_conv_json_query(const struct arg *args, struct sample *smp, void *private)
3734{
3735 struct buffer *trash = get_trash_chunk();
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003736 const char *token; /* holds the temporary string from mjson_find */
3737 int token_size; /* holds the length of <token> */
Alex51c8ad42021-04-15 16:45:15 +02003738
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003739 enum mjson_tok token_type;
Alex51c8ad42021-04-15 16:45:15 +02003740
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003741 token_type = mjson_find(smp->data.u.str.area, smp->data.u.str.data, args[0].data.str.area, &token, &token_size);
3742
3743 switch (token_type) {
Alex51c8ad42021-04-15 16:45:15 +02003744 case MJSON_TOK_NUMBER:
3745 if (args[1].type == ARGT_SINT) {
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003746 smp->data.u.sint = atoll(token);
Alex51c8ad42021-04-15 16:45:15 +02003747
3748 if (smp->data.u.sint < JSON_INT_MIN || smp->data.u.sint > JSON_INT_MAX)
3749 return 0;
3750
3751 smp->data.type = SMP_T_SINT;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003752
3753 return 1;
Alex51c8ad42021-04-15 16:45:15 +02003754 } else {
3755 double double_val;
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003756
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003757 if (mjson_get_number(smp->data.u.str.area, smp->data.u.str.data, args[0].data.str.area, &double_val) == 0)
Alex51c8ad42021-04-15 16:45:15 +02003758 return 0;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003759
3760 trash->data = snprintf(trash->area,trash->size,"%g",double_val);
3761 smp->data.u.str = *trash;
3762 smp->data.type = SMP_T_STR;
3763
3764 return 1;
Alex51c8ad42021-04-15 16:45:15 +02003765 }
Alex51c8ad42021-04-15 16:45:15 +02003766 case MJSON_TOK_TRUE:
3767 smp->data.type = SMP_T_BOOL;
3768 smp->data.u.sint = 1;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003769
3770 return 1;
Alex51c8ad42021-04-15 16:45:15 +02003771 case MJSON_TOK_FALSE:
3772 smp->data.type = SMP_T_BOOL;
3773 smp->data.u.sint = 0;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003774
3775 return 1;
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003776 case MJSON_TOK_STRING: {
3777 int len;
3778
3779 len = mjson_get_string(smp->data.u.str.area, smp->data.u.str.data, args[0].data.str.area, trash->area, trash->size);
3780
3781 if (len == -1) {
Alex51c8ad42021-04-15 16:45:15 +02003782 /* invalid string */
3783 return 0;
Alex51c8ad42021-04-15 16:45:15 +02003784 }
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003785
3786 trash->data = len;
3787 smp->data.u.str = *trash;
3788 smp->data.type = SMP_T_STR;
3789
3790 return 1;
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003791 }
Tim Duesterhus8f3bc8f2021-04-15 18:14:32 +02003792 case MJSON_TOK_NULL:
3793 case MJSON_TOK_ARRAY:
3794 case MJSON_TOK_OBJECT:
3795 /* We cannot handle these. */
3796 return 0;
3797 case MJSON_TOK_INVALID:
3798 /* Nothing matches the query. */
3799 return 0;
3800 case MJSON_TOK_KEY:
3801 /* This is not a valid return value according to the
3802 * mjson documentation, but we handle it to benefit
3803 * from '-Wswitch'.
3804 */
Alex51c8ad42021-04-15 16:45:15 +02003805 return 0;
3806 }
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003807
3808 my_unreachable();
3809 return 0;
Alex51c8ad42021-04-15 16:45:15 +02003810}
3811
3812
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003813/************************************************************************/
3814/* All supported sample fetch functions must be declared here */
3815/************************************************************************/
3816
3817/* force TRUE to be returned at the fetch level */
3818static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003819smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003820{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003821 if (!smp_make_rw(smp))
3822 return 0;
3823
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003824 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003825 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003826 return 1;
3827}
3828
3829/* force FALSE to be returned at the fetch level */
3830static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003831smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003832{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003833 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003834 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003835 return 1;
3836}
3837
3838/* retrieve environment variable $1 as a string */
3839static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003840smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003841{
3842 char *env;
3843
Christopher Faulete6e7a582021-01-29 11:29:28 +01003844 if (args[0].type != ARGT_STR)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003845 return 0;
3846
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003847 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003848 if (!env)
3849 return 0;
3850
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003851 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003852 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003853 smp->data.u.str.area = env;
3854 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003855 return 1;
3856}
3857
Damien Claisseae6f1252019-10-30 15:57:28 +00003858/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3859 * optional string representing the unit of the result: "s" for seconds, "ms" for
3860 * milliseconds and "us" for microseconds.
3861 * Returns 0 on error and non-zero if OK.
3862 */
3863int smp_check_date_unit(struct arg *args, char **err)
3864{
3865 if (args[1].type == ARGT_STR) {
Christopher Faulet95917132020-08-05 23:07:07 +02003866 long long int unit;
3867
Damien Claisseae6f1252019-10-30 15:57:28 +00003868 if (strcmp(args[1].data.str.area, "s") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003869 unit = TIME_UNIT_S;
Damien Claisseae6f1252019-10-30 15:57:28 +00003870 }
3871 else if (strcmp(args[1].data.str.area, "ms") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003872 unit = TIME_UNIT_MS;
Damien Claisseae6f1252019-10-30 15:57:28 +00003873 }
3874 else if (strcmp(args[1].data.str.area, "us") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003875 unit = TIME_UNIT_US;
Damien Claisseae6f1252019-10-30 15:57:28 +00003876 }
3877 else {
3878 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3879 args[1].data.str.area);
3880 return 0;
3881 }
Christopher Faulet95917132020-08-05 23:07:07 +02003882
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003883 chunk_destroy(&args[1].data.str);
Damien Claisseae6f1252019-10-30 15:57:28 +00003884 args[1].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02003885 args[1].data.sint = unit;
Damien Claisseae6f1252019-10-30 15:57:28 +00003886 }
3887 else if (args[1].type != ARGT_STOP) {
3888 memprintf(err, "Unexpected arg type");
3889 return 0;
3890 }
3891
3892 return 1;
3893}
3894
3895/* retrieve the current local date in epoch time, converts it to milliseconds
3896 * or microseconds if asked to in optional args[1] unit param, and applies an
3897 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003898 */
3899static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003900smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003901{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003902 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003903
Damien Claisseae6f1252019-10-30 15:57:28 +00003904 /* report in milliseconds */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003905 if (args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
Damien Claisseae6f1252019-10-30 15:57:28 +00003906 smp->data.u.sint *= 1000;
3907 smp->data.u.sint += date.tv_usec / 1000;
3908 }
3909 /* report in microseconds */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003910 else if (args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
Damien Claisseae6f1252019-10-30 15:57:28 +00003911 smp->data.u.sint *= 1000000;
3912 smp->data.u.sint += date.tv_usec;
3913 }
3914
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003915 /* add offset */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003916 if (args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003917 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003918
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003919 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003920 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3921 return 1;
3922}
3923
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003924/* retrieve the current microsecond part of the date */
3925static int
3926smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3927{
3928 smp->data.u.sint = date.tv_usec;
3929 smp->data.type = SMP_T_SINT;
3930 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3931 return 1;
3932}
3933
3934
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003935/* returns the hostname */
3936static int
3937smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3938{
3939 smp->data.type = SMP_T_STR;
3940 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003941 smp->data.u.str.area = hostname;
3942 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003943 return 1;
3944}
3945
Willy Tarreau0f30d262014-11-24 16:02:05 +01003946/* returns the number of processes */
3947static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003948smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003949{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003950 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003951 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003952 return 1;
3953}
3954
3955/* returns the number of the current process (between 1 and nbproc */
3956static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003957smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003958{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003959 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003960 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003961 return 1;
3962}
3963
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003964/* returns the number of the current thread (between 1 and nbthread */
3965static int
3966smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3967{
3968 smp->data.type = SMP_T_SINT;
3969 smp->data.u.sint = tid;
3970 return 1;
3971}
3972
Willy Tarreau84310e22014-02-14 11:59:04 +01003973/* generate a random 32-bit integer for whatever purpose, with an optional
3974 * range specified in argument.
3975 */
3976static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003977smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003978{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003979 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003980
3981 /* reduce if needed. Don't do a modulo, use all bits! */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003982 if (args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003983 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003984
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003985 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003986 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3987 return 1;
3988}
3989
Willy Tarreau0f30d262014-11-24 16:02:05 +01003990/* returns true if the current process is stopping */
3991static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003992smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003993{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003994 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003995 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003996 return 1;
3997}
3998
Willy Tarreau70fe9442018-11-22 16:07:39 +01003999/* returns the number of calls of the current stream's process_stream() */
4000static int
4001smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
4002{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004003 if (!smp->strm)
4004 return 0;
4005
Willy Tarreau70fe9442018-11-22 16:07:39 +01004006 smp->data.type = SMP_T_SINT;
4007 smp->data.u.sint = smp->strm->task->calls;
4008 return 1;
4009}
4010
4011/* returns the average number of nanoseconds spent processing the stream per call */
4012static int
4013smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
4014{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004015 if (!smp->strm)
4016 return 0;
4017
Willy Tarreau70fe9442018-11-22 16:07:39 +01004018 smp->data.type = SMP_T_SINT;
4019 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
4020 return 1;
4021}
4022
4023/* returns the total number of nanoseconds spent processing the stream */
4024static int
4025smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
4026{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004027 if (!smp->strm)
4028 return 0;
4029
Willy Tarreau70fe9442018-11-22 16:07:39 +01004030 smp->data.type = SMP_T_SINT;
4031 smp->data.u.sint = smp->strm->task->cpu_time;
4032 return 1;
4033}
4034
4035/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
4036static int
4037smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
4038{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004039 if (!smp->strm)
4040 return 0;
4041
Willy Tarreau70fe9442018-11-22 16:07:39 +01004042 smp->data.type = SMP_T_SINT;
4043 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
4044 return 1;
4045}
4046
4047/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
4048static int
4049smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
4050{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004051 if (!smp->strm)
4052 return 0;
4053
Willy Tarreau70fe9442018-11-22 16:07:39 +01004054 smp->data.type = SMP_T_SINT;
4055 smp->data.u.sint = smp->strm->task->lat_time;
4056 return 1;
4057}
4058
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004059static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
4060{
4061 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004062 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004063 smp->data.u.str.area = args[0].data.str.area;
4064 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004065 return 1;
4066}
4067
4068static int smp_check_const_bool(struct arg *args, char **err)
4069{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004070 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
4071 strcasecmp(args[0].data.str.area, "1") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004072 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004073 args[0].type = ARGT_SINT;
4074 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004075 return 1;
4076 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004077 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
4078 strcasecmp(args[0].data.str.area, "0") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004079 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004080 args[0].type = ARGT_SINT;
4081 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004082 return 1;
4083 }
4084 memprintf(err, "Expects 'true', 'false', '0' or '1'");
4085 return 0;
4086}
4087
4088static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
4089{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004090 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004091 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004092 return 1;
4093}
4094
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02004095static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004096{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004097 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004098 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004099 return 1;
4100}
4101
4102static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
4103{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004104 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004105 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004106 return 1;
4107}
4108
4109static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
4110{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004111 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004112 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004113 return 1;
4114}
4115
4116static int smp_check_const_bin(struct arg *args, char **err)
4117{
David Carlier64a16ab2016-04-08 10:37:02 +01004118 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004119 int binstrlen;
4120
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004121 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004122 return 0;
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004123 chunk_destroy(&args[0].data.str);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004124 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004125 args[0].data.str.area = binstr;
4126 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004127 return 1;
4128}
4129
4130static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
4131{
4132 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004133 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004134 smp->data.u.str.area = args[0].data.str.area;
4135 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004136 return 1;
4137}
4138
4139static int smp_check_const_meth(struct arg *args, char **err)
4140{
4141 enum http_meth_t meth;
4142 int i;
4143
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004144 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004145 if (meth != HTTP_METH_OTHER) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004146 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004147 args[0].type = ARGT_SINT;
4148 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004149 } else {
Ilya Shipitsin6b79f382020-07-23 00:32:55 +05004150 /* Check method avalaibility. A method is a token defined as :
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004151 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
4152 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
4153 * token = 1*tchar
4154 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004155 for (i = 0; i < args[0].data.str.data; i++) {
4156 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004157 memprintf(err, "expects valid method.");
4158 return 0;
4159 }
4160 }
4161 }
4162 return 1;
4163}
4164
4165static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
4166{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004167 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004168 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004169 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004170 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004171 smp->data.u.meth.str.area = "";
4172 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004173 } else {
4174 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004175 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004176 smp->data.u.meth.str.area = args[0].data.str.area;
4177 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004178 }
4179 return 1;
4180}
4181
Luca Schimweg8a694b82019-09-10 15:42:52 +02004182// This function checks the "uuid" sample's arguments.
4183// Function won't get called when no parameter is specified (maybe a bug?)
4184static int smp_check_uuid(struct arg *args, char **err)
4185{
4186 if (!args[0].type) {
4187 args[0].type = ARGT_SINT;
4188 args[0].data.sint = 4;
4189 }
4190 else if (args[0].data.sint != 4) {
4191 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
4192 return 0;
4193 }
4194
4195 return 1;
4196}
4197
4198// Generate a RFC4122 UUID (default is v4 = fully random)
4199static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
4200{
4201 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01004202 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02004203 smp->data.type = SMP_T_STR;
4204 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
4205 smp->data.u.str = trash;
4206 return 1;
4207 }
4208
4209 // more implementations of other uuid formats possible here
4210 return 0;
4211}
4212
Willy Tarreau5b8ad222013-07-25 12:17:57 +02004213/* Note: must not be declared <const> as its list will be overwritten.
4214 * Note: fetches that may return multiple types must be declared as the lowest
4215 * common denominator, the type that can be casted into all other ones. For
4216 * instance IPv4/IPv6 must be declared IPv4.
4217 */
4218static struct sample_fetch_kw_list smp_kws = {ILH, {
Willy Tarreau0209c972021-03-26 12:03:11 +01004219 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_CONST },
4220 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_CONST },
4221 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_CONST },
4222 { "date", smp_fetch_date, ARG2(0,SINT,STR), smp_check_date_unit, SMP_T_SINT, SMP_USE_CONST },
4223 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_CONST },
4224 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_CONST },
4225 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_CONST },
4226 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_CONST },
4227 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_CONST },
4228 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_CONST },
Willy Tarreau0f30d262014-11-24 16:02:05 +01004229 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau0209c972021-03-26 12:03:11 +01004230 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_CONST },
Willy Tarreau70fe9442018-11-22 16:07:39 +01004231
4232 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4233 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4234 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4235 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4236 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004237
Willy Tarreau0209c972021-03-26 12:03:11 +01004238 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_CONST },
4239 { "bool", smp_fetch_const_bool, ARG1(1,STR), smp_check_const_bool, SMP_T_BOOL, SMP_USE_CONST },
4240 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_CONST },
4241 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_CONST },
4242 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_CONST },
4243 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_CONST },
4244 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_CONST },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004245
Willy Tarreau5b8ad222013-07-25 12:17:57 +02004246 { /* END */ },
4247}};
4248
Willy Tarreau0108d902018-11-25 19:14:37 +01004249INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
4250
Emeric Brun107ca302010-01-04 16:16:05 +01004251/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02004252static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Moemen MHEDHBI848216f2021-04-02 01:05:07 +02004253 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
4254 { "b64dec", sample_conv_base642bin, 0, NULL, SMP_T_STR, SMP_T_BIN },
4255 { "base64", sample_conv_bin2base64, 0, NULL, SMP_T_BIN, SMP_T_STR },
4256 { "ub64enc", sample_conv_bin2base64url,0, NULL, SMP_T_BIN, SMP_T_STR },
4257 { "ub64dec", sample_conv_base64url2bin,0, NULL, SMP_T_STR, SMP_T_BIN },
4258 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
4259 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
4260 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
4261 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
4262 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
4263 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
4264 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
4265 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
4266 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4267 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4268 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4269 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4270 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4271 { "xxh3", sample_conv_xxh3, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4272 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4273 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4274 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
4275 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
4276 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
4277 { "word", sample_conv_word, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
4278 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
4279 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02004280#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01004281 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Ilya Shipitsin2c481d02021-03-26 23:35:31 +05004282#ifdef EVP_CIPH_GCM_MODE
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02004283 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
4284#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02004285 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
4286 { "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 +02004287#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01004288 { "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 +02004289 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02004290#ifdef USE_OPENSSL
4291 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
4292#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01004293
4294 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01004295 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
4296 { "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 +01004297
Baptiste Assmanne138dda2020-10-22 15:39:03 +02004298 /* FIX converters */
4299 { "fix_is_valid", sample_conv_fix_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4300 { "fix_tag_value", sample_conv_fix_tag_value, ARG1(1,STR), sample_conv_fix_value_check, SMP_T_BIN, SMP_T_BIN },
4301
Baptiste Assmanne279ca62020-10-27 18:10:06 +01004302 /* MQTT converters */
4303 { "mqtt_is_valid", sample_conv_mqtt_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4304 { "mqtt_field_value", sample_conv_mqtt_field_value, ARG2(2,STR,STR), sample_conv_mqtt_field_value_check, SMP_T_BIN, SMP_T_STR },
4305
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02004306 { "iif", sample_conv_iif, ARG2(2, STR, STR), NULL, SMP_T_BOOL, SMP_T_STR },
4307
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02004308 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4309 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4310 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4311 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
4312 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4313 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4314 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4315 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4316 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4317 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4318 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4319 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4320 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4321 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01004322
Christopher Fauletea159d62020-04-01 16:21:44 +02004323 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
4324 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02004325 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02004326 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Alex51c8ad42021-04-15 16:45:15 +02004327 { "json_query", sample_conv_json_query, ARG2(1,STR,STR), sample_check_json_query , SMP_T_STR, SMP_T_ANY },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02004328 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01004329}};
4330
Willy Tarreau0108d902018-11-25 19:14:37 +01004331INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);