blob: 33628ae48f69fbba7a7a647fabc978a627da42d6 [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 Tarreau9b340a02022-03-29 16:39:24 +0200328 [SMP_CKP_CFG_PARSER] = "configuration parser",
329 [SMP_CKP_CLI_PARSER] = "CLI parser",
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100330};
331
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100332/* This function returns the type of the data returned by the sample_expr.
333 * It assumes that the <expr> and all of its converters are properly
334 * initialized.
335 */
336inline
337int smp_expr_output_type(struct sample_expr *expr)
338{
339 struct sample_conv_expr *smp_expr;
340
341 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
342 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
343 return smp_expr->conv->out_type;
344 }
345 return expr->fetch->out_type;
346}
347
348
Willy Tarreau80aca902013-01-07 15:42:20 +0100349/* fill the trash with a comma-delimited list of source names for the <use> bit
350 * field which must be composed of a non-null set of SMP_USE_* flags. The return
351 * value is the pointer to the string in the trash buffer.
352 */
353const char *sample_src_names(unsigned int use)
354{
355 int bit;
356
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200357 trash.data = 0;
358 trash.area[0] = '\0';
Willy Tarreau80aca902013-01-07 15:42:20 +0100359 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
360 if (!(use & ~((1 << bit) - 1)))
361 break; /* no more bits */
362
363 if (!(use & (1 << bit)))
364 continue; /* bit not set */
365
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200366 trash.data += snprintf(trash.area + trash.data,
367 trash.size - trash.data, "%s%s",
368 (use & ((1 << bit) - 1)) ? "," : "",
369 fetch_src_names[bit]);
Willy Tarreau80aca902013-01-07 15:42:20 +0100370 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200371 return trash.area;
Willy Tarreau80aca902013-01-07 15:42:20 +0100372}
373
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100374/* return a pointer to the correct sample checkpoint name, or "unknown" when
375 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
376 * if set.
377 */
378const char *sample_ckp_names(unsigned int use)
379{
380 int bit;
381
382 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
383 if (use & (1 << bit))
384 return fetch_ckp_names[bit];
385 return "unknown sample check place, please report this bug";
386}
387
Emeric Brun107ca302010-01-04 16:16:05 +0100388/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100389 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
390 * for next parsing sessions. The fetch keywords capabilities are also computed
391 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100392 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100393void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100394{
Willy Tarreau80aca902013-01-07 15:42:20 +0100395 struct sample_fetch *sf;
396 int bit;
397
398 for (sf = kwl->kw; sf->kw != NULL; sf++) {
399 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
400 if (sf->use & (1 << bit))
401 sf->val |= fetch_cap[bit];
402 }
Willy Tarreau2b718102021-04-21 07:32:39 +0200403 LIST_APPEND(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100404}
405
406/*
Willy Tarreau12785782012-04-27 21:37:17 +0200407 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100408 * parsing sessions.
409 */
Willy Tarreau12785782012-04-27 21:37:17 +0200410void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100411{
Willy Tarreau2b718102021-04-21 07:32:39 +0200412 LIST_APPEND(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100413}
414
415/*
Willy Tarreau12785782012-04-27 21:37:17 +0200416 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100417 * string of <len> in buffer <kw>.
418 *
419 */
Willy Tarreau12785782012-04-27 21:37:17 +0200420struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100421{
422 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200423 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100424
Willy Tarreau12785782012-04-27 21:37:17 +0200425 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100426 for (index = 0; kwl->kw[index].kw != NULL; index++) {
427 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
428 kwl->kw[index].kw[len] == '\0')
429 return &kwl->kw[index];
430 }
431 }
432 return NULL;
433}
434
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100435/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100436 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100437 * <idx> is the index of the next sample fetch entry. It is used as private
438 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100439 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100440 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100441 * the list is reached.
442 */
443struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
444{
445 struct sample_fetch_kw_list *kwl;
446 struct sample_fetch *base;
447
448 if (!current) {
449 /* Get first kwl entry. */
450 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
451 (*idx) = 0;
452 } else {
453 /* Get kwl corresponding to the curret entry. */
454 base = current + 1 - (*idx);
455 kwl = container_of(base, struct sample_fetch_kw_list, kw);
456 }
457
458 while (1) {
459
460 /* Check if kwl is the last entry. */
461 if (&kwl->list == &sample_fetches.list)
462 return NULL;
463
464 /* idx contain the next keyword. If it is available, return it. */
465 if (kwl->kw[*idx].kw) {
466 (*idx)++;
467 return &kwl->kw[(*idx)-1];
468 }
469
470 /* get next entry in the main list, and return NULL if the end is reached. */
471 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
472
473 /* Set index to 0, ans do one other loop. */
474 (*idx) = 0;
475 }
476}
477
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100478/* This function browses the list of available converters. <current> is
479 * the last used converter. If it is the first call, it must set to NULL.
480 * <idx> is the index of the next converter entry. It is used as private
481 * value. It is useless to initiate it.
482 *
483 * It returns always the next sample_conv entry, and NULL when the end of
484 * the list is reached.
485 */
486struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
487{
488 struct sample_conv_kw_list *kwl;
489 struct sample_conv *base;
490
491 if (!current) {
492 /* Get first kwl entry. */
493 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
494 (*idx) = 0;
495 } else {
496 /* Get kwl corresponding to the curret entry. */
497 base = current + 1 - (*idx);
498 kwl = container_of(base, struct sample_conv_kw_list, kw);
499 }
500
501 while (1) {
502 /* Check if kwl is the last entry. */
503 if (&kwl->list == &sample_convs.list)
504 return NULL;
505
506 /* idx contain the next keyword. If it is available, return it. */
507 if (kwl->kw[*idx].kw) {
508 (*idx)++;
509 return &kwl->kw[(*idx)-1];
510 }
511
512 /* get next entry in the main list, and return NULL if the end is reached. */
513 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
514
515 /* Set index to 0, ans do one other loop. */
516 (*idx) = 0;
517 }
518}
519
Emeric Brun107ca302010-01-04 16:16:05 +0100520/*
Willy Tarreau12785782012-04-27 21:37:17 +0200521 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100522 * string of <len> in buffer <kw>.
523 *
524 */
Willy Tarreau12785782012-04-27 21:37:17 +0200525struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100526{
527 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200528 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100529
Willy Tarreau12785782012-04-27 21:37:17 +0200530 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100531 for (index = 0; kwl->kw[index].kw != NULL; index++) {
532 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
533 kwl->kw[index].kw[len] == '\0')
534 return &kwl->kw[index];
535 }
536 }
537 return NULL;
538}
539
Emeric Brun107ca302010-01-04 16:16:05 +0100540/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200541/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100542/******************************************************************/
543
Willy Tarreau342acb42012-04-23 22:03:39 +0200544static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100545{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200546 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200547 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100548 return 1;
549}
550
Willy Tarreau342acb42012-04-23 22:03:39 +0200551static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100552{
Willy Tarreau83061a82018-07-13 11:56:34 +0200553 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100554
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200555 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100556 return 0;
557
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200558 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200559 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200560 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100561 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100562
563 return 1;
564}
565
Willy Tarreau342acb42012-04-23 22:03:39 +0200566static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100567{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200568 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200569 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100570 return 1;
571}
572
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200573static int c_ipv62ip(struct sample *smp)
574{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200575 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200576 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100577 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200578 return 1;
579}
580
Willy Tarreau342acb42012-04-23 22:03:39 +0200581static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100582{
Willy Tarreau83061a82018-07-13 11:56:34 +0200583 struct buffer *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100584
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200585 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100586 return 0;
587
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200588 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200589 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200590 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100591 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100592 return 1;
593}
594
595/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200596static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100597{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200598 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100599}
600*/
601
Willy Tarreau342acb42012-04-23 22:03:39 +0200602static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100603{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200604 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200605 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100606 return 1;
607}
608
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200609static int c_int2ipv6(struct sample *smp)
610{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200611 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
612 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200613 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200614 return 1;
615}
616
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100617static int c_str2addr(struct sample *smp)
618{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200619 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4)) {
620 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100621 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200622 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100623 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100624 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100625 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200626 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100627 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100628 return 1;
629}
630
Willy Tarreau342acb42012-04-23 22:03:39 +0200631static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100632{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200633 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100634 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200635 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100636 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100637 return 1;
638}
639
Willy Tarreau342acb42012-04-23 22:03:39 +0200640static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100641{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200642 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100643 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200644 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100645 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100646 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100647}
648
Emeric Brun4b9e8022014-11-03 18:17:10 +0100649/*
650 * The NULL char always enforces the end of string if it is met.
651 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100652 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200653static int c_bin2str(struct sample *smp)
654{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100655 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200656
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200657 for (i = 0; i < smp->data.u.str.data; i++) {
658 if (!smp->data.u.str.area[i]) {
659 smp->data.u.str.data = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100660 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100661 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200662 }
Christopher Faulet472ad512020-04-30 09:57:40 +0200663 smp->data.type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200664 return 1;
665}
666
Willy Tarreau342acb42012-04-23 22:03:39 +0200667static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100668{
Willy Tarreau83061a82018-07-13 11:56:34 +0200669 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100670 char *pos;
671
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200672 pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100673 if (!pos)
674 return 0;
675
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200676 trash->size = trash->size - (pos - trash->area);
677 trash->area = pos;
678 trash->data = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200679 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200680 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100681 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100682 return 1;
683}
684
Joseph Herlant757f5ad2018-11-15 12:14:56 -0800685/* This function unconditionally duplicates data and removes the "const" flag.
Willy Tarreauad635822016-08-08 19:21:09 +0200686 * For strings and binary blocks, it also provides a known allocated size with
687 * a length that is capped to the size, and ensures a trailing zero is always
688 * appended for strings. This is necessary for some operations which may
689 * require to extend the length. It returns 0 if it fails, 1 on success.
690 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100691int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200692{
Willy Tarreau83061a82018-07-13 11:56:34 +0200693 struct buffer *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200694
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200695 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100696 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100697 case SMP_T_SINT:
698 case SMP_T_ADDR:
699 case SMP_T_IPV4:
700 case SMP_T_IPV6:
701 /* These type are not const. */
702 break;
Willy Tarreauad635822016-08-08 19:21:09 +0200703
Christopher Fauletec100512017-07-24 15:38:41 +0200704 case SMP_T_METH:
705 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
706 break;
707 /* Fall through */
708
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100709 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200710 trash = get_trash_chunk();
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100711 trash->data = smp->data.type == SMP_T_STR ?
712 smp->data.u.str.data : smp->data.u.meth.str.data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200713 if (trash->data > trash->size - 1)
714 trash->data = trash->size - 1;
Willy Tarreauad635822016-08-08 19:21:09 +0200715
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100716 memcpy(trash->area, smp->data.type == SMP_T_STR ?
717 smp->data.u.str.area : smp->data.u.meth.str.area,
718 trash->data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200719 trash->area[trash->data] = 0;
Willy Tarreauad635822016-08-08 19:21:09 +0200720 smp->data.u.str = *trash;
721 break;
722
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100723 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100724 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200725 trash->data = smp->data.u.str.data;
726 if (trash->data > trash->size)
727 trash->data = trash->size;
Willy Tarreauad635822016-08-08 19:21:09 +0200728
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200729 memcpy(trash->area, smp->data.u.str.area, trash->data);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200730 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100731 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200732
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100733 default:
734 /* Other cases are unexpected. */
735 return 0;
736 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100737
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100738 /* remove const flag */
739 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200740 return 1;
741}
742
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100743int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100744{
745 return 1;
746}
747
Willy Tarreau342acb42012-04-23 22:03:39 +0200748static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100749{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200750 const char *str;
751 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100752
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200753 if (smp->data.u.str.data == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100754 return 0;
755
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200756 str = smp->data.u.str.area;
757 end = smp->data.u.str.area + smp->data.u.str.data;
Emeric Brun107ca302010-01-04 16:16:05 +0100758
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200759 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200760 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100761 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100762 return 1;
763}
764
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100765static int c_str2meth(struct sample *smp)
766{
767 enum http_meth_t meth;
768 int len;
769
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200770 meth = find_http_meth(smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100771 if (meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200772 len = smp->data.u.str.data;
773 smp->data.u.meth.str.area = smp->data.u.str.area;
774 smp->data.u.meth.str.data = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100775 }
776 else
777 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200778 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200779 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100780 return 1;
781}
782
783static int c_meth2str(struct sample *smp)
784{
785 int len;
786 enum http_meth_t meth;
787
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200788 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100789 /* The method is unknown. Copy the original pointer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200790 len = smp->data.u.meth.str.data;
791 smp->data.u.str.area = smp->data.u.meth.str.area;
792 smp->data.u.str.data = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200793 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100794 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200795 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100796 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200797 meth = smp->data.u.meth.meth;
Willy Tarreau35b51c62018-09-10 15:38:55 +0200798 smp->data.u.str.area = http_known_methods[meth].ptr;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200799 smp->data.u.str.data = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100800 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200801 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100802 }
803 else {
804 /* Unknown method */
805 return 0;
806 }
807 return 1;
808}
809
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200810static int c_addr2bin(struct sample *smp)
811{
Willy Tarreau83061a82018-07-13 11:56:34 +0200812 struct buffer *chk = get_trash_chunk();
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200813
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200814 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200815 chk->data = 4;
816 memcpy(chk->area, &smp->data.u.ipv4, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200817 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200818 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200819 chk->data = 16;
820 memcpy(chk->area, &smp->data.u.ipv6, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200821 }
822 else
823 return 0;
824
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200825 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200826 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200827 return 1;
828}
829
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200830static int c_int2bin(struct sample *smp)
831{
Willy Tarreau83061a82018-07-13 11:56:34 +0200832 struct buffer *chk = get_trash_chunk();
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200833
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200834 *(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
835 chk->data = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200836
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200837 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200838 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200839 return 1;
840}
841
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200842
Emeric Brun107ca302010-01-04 16:16:05 +0100843/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200844/* Sample casts matrix: */
845/* sample_casts[from type][to type] */
846/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100847/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100848
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100849sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200850/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
851/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
852/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200853/* 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 +0200854/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
855/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200856/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200857/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
858/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
859/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200860};
Emeric Brun107ca302010-01-04 16:16:05 +0100861
Emeric Brun107ca302010-01-04 16:16:05 +0100862/*
Willy Tarreau12785782012-04-27 21:37:17 +0200863 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100864 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200865 * Returns a pointer on allocated sample expression structure.
Christopher Faulet45bb15f2021-09-30 08:48:56 +0200866 * <al> is an arg_list serving as a list head to report missing dependencies.
867 * It may be NULL if such dependencies are not allowed. Otherwise, the caller
868 * must have set al->ctx if al is set.
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100869 * If <endptr> is non-nul, it will be set to the first unparsed character
870 * (which may be the final '\0') on success. If it is nul, the expression
871 * must be properly terminated by a '\0' otherwise an error is reported.
Emeric Brun107ca302010-01-04 16:16:05 +0100872 */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100873struct 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 +0100874{
Willy Tarreau833cc792013-07-24 15:34:19 +0200875 const char *begw; /* beginning of word */
876 const char *endw; /* end of word */
877 const char *endt; /* end of term */
Remi Tricot-Le Breton22e0d9b2021-01-12 14:55:12 +0100878 struct sample_expr *expr = NULL;
Willy Tarreau12785782012-04-27 21:37:17 +0200879 struct sample_fetch *fetch;
880 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100881 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200882 char *fkw = NULL;
883 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100884 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100885
Willy Tarreau833cc792013-07-24 15:34:19 +0200886 begw = str[*idx];
Willy Tarreaued2c6622020-02-14 18:27:10 +0100887 for (endw = begw; is_idchar(*endw); endw++)
888 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200889
890 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100891 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100892 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200893 }
Emeric Brun107ca302010-01-04 16:16:05 +0100894
Willy Tarreau833cc792013-07-24 15:34:19 +0200895 /* keep a copy of the current fetch keyword for error reporting */
896 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100897
Willy Tarreau833cc792013-07-24 15:34:19 +0200898 fetch = find_sample_fetch(begw, endw - begw);
899 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100900 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100901 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200902 }
Emeric Brun107ca302010-01-04 16:16:05 +0100903
Willy Tarreau833cc792013-07-24 15:34:19 +0200904 /* At this point, we have :
905 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100906 * - endw : end of the keyword, first character not part of keyword
Willy Tarreau833cc792013-07-24 15:34:19 +0200907 */
908
909 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100910 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100911 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200912 }
Emeric Brun107ca302010-01-04 16:16:05 +0100913 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200914
Vincent Bernat02779b62016-04-03 13:48:43 +0200915 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200916 if (!expr)
917 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100918
919 LIST_INIT(&(expr->conv_exprs));
920 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200921 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100922
Willy Tarreau689a1df2013-12-13 00:40:11 +0100923 /* Note that we call the argument parser even with an empty string,
924 * this allows it to automatically create entries for mandatory
925 * implicit arguments (eg: local proxy name).
926 */
Christopher Faulet45bb15f2021-09-30 08:48:56 +0200927 if (al) {
928 al->kw = expr->fetch->kw;
929 al->conv = NULL;
930 }
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100931 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 +0100932 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
933 goto out_error;
934 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200935
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100936 /* now endt is our first char not part of the arg list, typically the
937 * comma after the sample fetch name or after the closing parenthesis,
938 * or the NUL char.
939 */
940
Willy Tarreau689a1df2013-12-13 00:40:11 +0100941 if (!expr->arg_p) {
942 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200943 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100944 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
945 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200946 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100947 }
948
Willy Tarreau833cc792013-07-24 15:34:19 +0200949 /* Now process the converters if any. We have two supported syntaxes
950 * for the converters, which can be combined :
951 * - comma-delimited list of converters just after the keyword and args ;
952 * - one converter per keyword
953 * The combination allows to have each keyword being a comma-delimited
954 * series of converters.
955 *
956 * We want to process the former first, then the latter. For this we start
957 * from the beginning of the supposed place in the exiting conv chain, which
958 * starts at the last comma (endt).
959 */
960
961 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200962 struct sample_conv_expr *conv_expr;
Willy Tarreau46dfd782019-12-17 10:25:29 +0100963 int err_arg;
964 int argcnt;
Emeric Brun107ca302010-01-04 16:16:05 +0100965
Willy Tarreau833cc792013-07-24 15:34:19 +0200966 if (*endt && *endt != ',') {
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100967 if (endptr) {
968 /* end found, let's stop here */
969 break;
970 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200971 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100972 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200973 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100974 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100975 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200976 }
Emeric Brun107ca302010-01-04 16:16:05 +0100977
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100978 /* FIXME: how long should we support such idiocies ? Maybe we
979 * should already warn ?
980 */
Willy Tarreau833cc792013-07-24 15:34:19 +0200981 while (*endt == ',') /* then trailing commas */
982 endt++;
983
Willy Tarreau97108e02016-11-25 07:33:24 +0100984 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200985
986 if (!*begw) {
987 /* none ? skip to next string */
988 (*idx)++;
989 begw = str[*idx];
990 if (!begw || !*begw)
991 break;
992 }
993
Willy Tarreaued2c6622020-02-14 18:27:10 +0100994 for (endw = begw; is_idchar(*endw); endw++)
995 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200996
997 free(ckw);
998 ckw = my_strndup(begw, endw - begw);
999
1000 conv = find_sample_conv(begw, endw - begw);
1001 if (!conv) {
1002 /* we found an isolated keyword that we don't know, it's not ours */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001003 if (begw == str[*idx]) {
1004 endt = begw;
Willy Tarreau833cc792013-07-24 15:34:19 +02001005 break;
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001006 }
Willy Tarreau97108e02016-11-25 07:33:24 +01001007 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +02001008 goto out_error;
1009 }
Emeric Brun107ca302010-01-04 16:16:05 +01001010
Willy Tarreau833cc792013-07-24 15:34:19 +02001011 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +01001012 memprintf(err_msg, "returns type of converter '%s' is unknown", 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 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +02001017 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +01001018 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001019 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +02001020 }
Emeric Brun107ca302010-01-04 16:16:05 +01001021
1022 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +02001023 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +02001024 if (!conv_expr)
1025 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001026
Willy Tarreau2b718102021-04-21 07:32:39 +02001027 LIST_APPEND(&(expr->conv_exprs), &(conv_expr->list));
Emeric Brun107ca302010-01-04 16:16:05 +01001028 conv_expr->conv = conv;
1029
Christopher Faulet45bb15f2021-09-30 08:48:56 +02001030 if (al) {
1031 al->kw = expr->fetch->kw;
1032 al->conv = conv_expr->conv->kw;
1033 }
Willy Tarreau80b53ff2020-02-14 08:40:37 +01001034 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 +01001035 if (argcnt < 0) {
1036 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
1037 goto out_error;
1038 }
Willy Tarreau9e92d322010-01-26 17:58:06 +01001039
Willy Tarreau46dfd782019-12-17 10:25:29 +01001040 if (argcnt && !conv->arg_mask) {
1041 memprintf(err_msg, "converter '%s' does not support any args", ckw);
1042 goto out_error;
1043 }
Willy Tarreau21d68a62012-04-20 15:52:36 +02001044
Willy Tarreau46dfd782019-12-17 10:25:29 +01001045 if (!conv_expr->arg_p)
1046 conv_expr->arg_p = empty_arg_list;
Willy Tarreau2e845be2012-10-19 19:49:09 +02001047
Willy Tarreau46dfd782019-12-17 10:25:29 +01001048 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
1049 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001050 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001051 }
1052 }
Emeric Brun485479d2010-09-23 18:02:19 +02001053
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001054 if (endptr) {
1055 /* end found, let's stop here */
1056 *endptr = (char *)endt;
1057 }
1058
Willy Tarreau833cc792013-07-24 15:34:19 +02001059 out:
1060 free(fkw);
1061 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001062 return expr;
1063
1064out_error:
Remi Tricot-Le Breton22e0d9b2021-01-12 14:55:12 +01001065 release_sample_expr(expr);
Willy Tarreau833cc792013-07-24 15:34:19 +02001066 expr = NULL;
1067 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001068}
1069
1070/*
Willy Tarreau12785782012-04-27 21:37:17 +02001071 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001072 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001073 * Returns a pointer on a typed sample structure containing the result or NULL if
1074 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001075 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001076 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001077 *
1078 * Note: the fetch functions are required to properly set the return type. The
1079 * conversion functions must do so too. However the cast functions do not need
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001080 * to since they're made to cast multiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001081 *
1082 * The caller may indicate in <opt> if it considers the result final or not.
1083 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1084 * if the result is stable or not, according to the following table :
1085 *
1086 * return MAY_CHANGE FINAL Meaning for the sample
1087 * NULL 0 * Not present and will never be (eg: header)
1088 * NULL 1 0 Not present yet, could change (eg: POST param)
1089 * NULL 1 1 Not present yet, will not change anymore
1090 * smp 0 * Present and will not change (eg: header)
1091 * smp 1 0 Present, may change (eg: request length)
1092 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001093 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001094struct sample *sample_process(struct proxy *px, struct session *sess,
1095 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001096 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001097{
Willy Tarreau12785782012-04-27 21:37:17 +02001098 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001099
Willy Tarreau18387e22013-07-25 12:02:38 +02001100 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001101 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001102 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001103 }
Emeric Brun107ca302010-01-04 16:16:05 +01001104
Willy Tarreau1777ea62016-03-10 16:15:46 +01001105 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001106 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001107 return NULL;
1108
Emeric Brun107ca302010-01-04 16:16:05 +01001109 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001110 /* we want to ensure that p->type can be casted into
1111 * conv_expr->conv->in_type. We have 3 possibilities :
1112 * - NULL => not castable.
1113 * - c_none => nothing to do (let's optimize it)
1114 * - other => apply cast and prepare to fail
1115 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001116 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001117 return NULL;
1118
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001119 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1120 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001121 return NULL;
1122
Willy Tarreau12e50112012-04-25 17:21:49 +02001123 /* OK cast succeeded */
1124
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001125 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001126 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001127 }
1128 return p;
1129}
1130
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001131/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001132 * Resolve all remaining arguments in proxy <p>. Returns the number of
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001133 * errors or 0 if everything is fine. If at least one error is met, it will
1134 * be appended to *err. If *err==NULL it will be allocated first.
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001135 */
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001136int smp_resolve_args(struct proxy *p, char **err)
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001137{
1138 struct arg_list *cur, *bak;
1139 const char *ctx, *where;
1140 const char *conv_ctx, *conv_pre, *conv_pos;
1141 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001142 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001143 struct arg *arg;
1144 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001145 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001146
1147 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1148 struct proxy *px;
1149 struct server *srv;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001150 struct stktable *t;
1151 char *pname, *sname, *stktname;
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001152 char *err2;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001153
1154 arg = cur->arg;
1155
1156 /* prepare output messages */
1157 conv_pre = conv_pos = conv_ctx = "";
1158 if (cur->conv) {
1159 conv_ctx = cur->conv;
1160 conv_pre = "conversion keyword '";
1161 conv_pos = "' for ";
1162 }
1163
1164 where = "in";
1165 ctx = "sample fetch keyword";
1166 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001167 case ARGC_STK: where = "in stick rule in"; break;
1168 case ARGC_TRK: where = "in tracking rule in"; break;
1169 case ARGC_LOG: where = "in log-format string in"; break;
1170 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
Willy Tarreaud9b331c2021-09-02 19:43:20 +02001171 case ARGC_HRQ: where = "in http-request expression in"; break;
1172 case ARGC_HRS: where = "in http-response response in"; break;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001173 case ARGC_UIF: where = "in unique-id-format string in"; break;
1174 case ARGC_RDR: where = "in redirect format string in"; break;
1175 case ARGC_CAP: where = "in capture rule in"; break;
1176 case ARGC_ACL: ctx = "ACL keyword"; break;
1177 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001178 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Christopher Faulet3b967c12020-05-15 15:47:44 +02001179 case ARGC_HERR: where = "in http-error directive in"; break;
Miroslav Zagorac7f8314c2020-12-09 16:31:48 +01001180 case ARGC_OT: where = "in ot-scope directive in"; break;
Willy Tarreaud9b331c2021-09-02 19:43:20 +02001181 case ARGC_TCO: where = "in tcp-request connection expression in"; break;
1182 case ARGC_TSE: where = "in tcp-request session expression in"; break;
1183 case ARGC_TRQ: where = "in tcp-request content expression in"; break;
1184 case ARGC_TRS: where = "in tcp-response content expression in"; break;
1185 case ARGC_TCK: where = "in tcp-check expression in"; break;
1186 case ARGC_CFG: where = "in configuration expression in"; break;
1187 case ARGC_CLI: where = "in CLI expression in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001188 }
1189
1190 /* set a few default settings */
1191 px = p;
1192 pname = p->id;
1193
1194 switch (arg->type) {
1195 case ARGT_SRV:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001196 if (!arg->data.str.data) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001197 memprintf(err, "%sparsing [%s:%d]: missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1198 *err ? *err : "", cur->file, cur->line,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001199 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001200 cfgerr++;
1201 continue;
1202 }
1203
1204 /* we support two formats : "bck/srv" and "srv" */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001205 sname = strrchr(arg->data.str.area, '/');
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001206
1207 if (sname) {
1208 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001209 pname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001210
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001211 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001212 if (!px) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001213 memprintf(err, "%sparsing [%s:%d]: unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1214 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001215 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001216 cfgerr++;
1217 break;
1218 }
1219 }
1220 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001221 sname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001222
1223 srv = findserver(px, sname);
1224 if (!srv) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001225 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",
1226 *err ? *err : "", cur->file, cur->line, sname, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001227 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001228 cfgerr++;
1229 break;
1230 }
1231
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001232 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001233 arg->unresolved = 0;
1234 arg->data.srv = srv;
1235 break;
1236
1237 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001238 if (arg->data.str.data) {
1239 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001240 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001241 }
1242
1243 if (!px) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001244 memprintf(err, "%sparsing [%s:%d]: unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1245 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001246 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001247 cfgerr++;
1248 break;
1249 }
1250
1251 if (!(px->cap & PR_CAP_FE)) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001252 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",
1253 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001254 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001255 cfgerr++;
1256 break;
1257 }
1258
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001259 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001260 arg->unresolved = 0;
1261 arg->data.prx = px;
1262 break;
1263
1264 case ARGT_BE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001265 if (arg->data.str.data) {
1266 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001267 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001268 }
1269
1270 if (!px) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001271 memprintf(err, "%sparsing [%s:%d]: unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1272 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001273 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001274 cfgerr++;
1275 break;
1276 }
1277
1278 if (!(px->cap & PR_CAP_BE)) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001279 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",
1280 *err ? *err : "", cur->file, cur->line, pname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001281 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001282 cfgerr++;
1283 break;
1284 }
1285
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001286 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001287 arg->unresolved = 0;
1288 arg->data.prx = px;
1289 break;
1290
1291 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001292 if (arg->data.str.data)
1293 stktname = arg->data.str.area;
1294 else
1295 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001296
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001297 t = stktable_find_by_name(stktname);
1298 if (!t) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001299 memprintf(err, "%sparsing [%s:%d]: unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1300 *err ? *err : "", cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001301 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001302 cfgerr++;
1303 break;
1304 }
1305
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001306 if (!t->size) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001307 memprintf(err, "%sparsing [%s:%d]: no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1308 *err ? *err : "", cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001309 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001310 cfgerr++;
1311 break;
1312 }
1313
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001314 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001315 memprintf(err, "%sparsing [%s:%d]: stick-table '%s' not present on all processes covered by proxy '%s'.\n",
1316 *err ? *err : "", cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001317 cfgerr++;
1318 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001319 }
1320
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001321 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001322 p->next_stkt_ref = t->proxies_list;
1323 t->proxies_list = p;
1324 }
1325
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001326 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001327 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001328 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001329 break;
1330
1331 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001332 if (!arg->data.str.data) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001333 memprintf(err, "%sparsing [%s:%d]: missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1334 *err ? *err : "", cur->file, cur->line,
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
1340 if (p->uri_auth && p->uri_auth->userlist &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001341 strcmp(p->uri_auth->userlist->name, arg->data.str.area) == 0)
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001342 ul = p->uri_auth->userlist;
1343 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001344 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001345
1346 if (!ul) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001347 memprintf(err, "%sparsing [%s:%d]: unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1348 *err ? *err : "", cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001349 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001350 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001351 cfgerr++;
1352 break;
1353 }
1354
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001355 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001356 arg->unresolved = 0;
1357 arg->data.usr = ul;
1358 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001359
1360 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001361 if (!arg->data.str.data) {
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001362 memprintf(err, "%sparsing [%s:%d]: missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1363 *err ? *err : "", cur->file, cur->line,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001364 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001365 cfgerr++;
1366 continue;
1367 }
1368
Willy Tarreau46947782015-01-19 19:00:58 +01001369 rflags = 0;
1370 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001371 err2 = NULL;
Willy Tarreau46947782015-01-19 19:00:58 +01001372
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001373 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err2))) {
1374 memprintf(err, "%sparsing [%s:%d]: error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1375 *err ? *err : "", cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001376 arg->data.str.area,
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01001377 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err2);
Willy Tarreau46947782015-01-19 19:00:58 +01001378 cfgerr++;
1379 continue;
1380 }
1381
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001382 chunk_destroy(&arg->data.str);
Willy Tarreau46947782015-01-19 19:00:58 +01001383 arg->unresolved = 0;
1384 arg->data.reg = reg;
1385 break;
1386
1387
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001388 }
1389
Willy Tarreau2b718102021-04-21 07:32:39 +02001390 LIST_DELETE(&cur->list);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001391 free(cur);
1392 } /* end of args processing */
1393
1394 return cfgerr;
1395}
1396
1397/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001398 * Process a fetch + format conversion as defined by the sample expression
1399 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001400 * not explicitly set to <smp_type>, but shall be compatible with it as
1401 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1402 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001403 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1404 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1405 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1406 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001407 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1408 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1409 * still hope to get it after waiting longer, and is not converted to string.
1410 * The possible output combinations are the following :
1411 *
1412 * return MAY_CHANGE FINAL Meaning for the sample
1413 * NULL * * Not present and will never be (eg: header)
1414 * smp 0 * Final value converted (eg: header)
1415 * smp 1 0 Not present yet, may appear later (eg: header)
1416 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001417 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001418struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001419 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001420 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001421{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001422 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001423
Willy Tarreau6c616e02014-06-25 16:56:41 +02001424 memset(smp, 0, sizeof(*smp));
1425
Willy Tarreau192252e2015-04-04 01:47:55 +02001426 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001427 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1428 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001429 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001430 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001431
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001432 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001433 return NULL;
1434
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001435 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001436 return NULL;
1437
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001438 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001439 return smp;
1440}
1441
Christopher Faulet476e5d02016-10-26 11:34:47 +02001442static void release_sample_arg(struct arg *p)
1443{
1444 struct arg *p_back = p;
1445
1446 if (!p)
1447 return;
1448
1449 while (p->type != ARGT_STOP) {
1450 if (p->type == ARGT_STR || p->unresolved) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001451 chunk_destroy(&p->data.str);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001452 p->unresolved = 0;
1453 }
1454 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001455 regex_free(p->data.reg);
1456 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001457 }
1458 p++;
1459 }
1460
1461 if (p_back != empty_arg_list)
1462 free(p_back);
1463}
1464
1465void release_sample_expr(struct sample_expr *expr)
1466{
1467 struct sample_conv_expr *conv_expr, *conv_exprb;
1468
1469 if (!expr)
1470 return;
1471
Tim Duesterhus867cd982020-07-04 11:49:39 +02001472 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001473 LIST_DELETE(&conv_expr->list);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001474 release_sample_arg(conv_expr->arg_p);
Tim Duesterhus867cd982020-07-04 11:49:39 +02001475 free(conv_expr);
1476 }
1477
Christopher Faulet476e5d02016-10-26 11:34:47 +02001478 release_sample_arg(expr->arg_p);
1479 free(expr);
1480}
1481
Emeric Brun107ca302010-01-04 16:16:05 +01001482/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001483/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001484/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001485/*****************************************************************/
1486
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001487static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1488{
1489 int i;
1490 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001491 struct buffer *buf;
1492 struct sink *sink;
1493 struct ist line;
1494 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001495
Willy Tarreau0851fd52019-12-17 10:07:25 +01001496 buf = alloc_trash_chunk();
1497 if (!buf)
1498 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001499
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001500 sink = (struct sink *)arg_p[1].data.ptr;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001501 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001502
Willy Tarreau0851fd52019-12-17 10:07:25 +01001503 pfx = arg_p[0].data.str.area;
1504 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001505
Willy Tarreau0851fd52019-12-17 10:07:25 +01001506 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1507 if (!sample_casts[smp->data.type][SMP_T_STR])
1508 goto nocast;
1509
1510 /* Copy sample fetch. This puts the sample as const, the
1511 * cast will copy data if a transformation is required.
1512 */
1513 memcpy(&tmp, smp, sizeof(struct sample));
1514 tmp.flags = SMP_F_CONST;
1515
1516 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1517 goto nocast;
1518
1519 /* Display the displayable chars*. */
1520 b_putchr(buf, '<');
1521 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001522 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001523 b_putchr(buf, tmp.data.u.str.area[i]);
1524 else
1525 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001526 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001527 b_putchr(buf, '>');
1528
1529 done:
1530 line = ist2(buf->area, buf->data);
Aurelien DARRAGONc2423132023-06-26 16:44:41 +02001531 sink_write(sink, 0, &line, 1, 0, 0, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001532 end:
1533 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001534 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001535 nocast:
1536 chunk_appendf(buf, "(undisplayable)");
1537 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001538}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001539
1540// This function checks the "debug" converter's arguments.
1541static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1542 const char *file, int line, char **err)
1543{
1544 const char *name = "buf0";
1545 struct sink *sink = NULL;
1546
1547 if (args[0].type != ARGT_STR) {
1548 /* optional prefix */
1549 args[0].data.str.area = "";
1550 args[0].data.str.data = 0;
1551 }
1552
1553 if (args[1].type == ARGT_STR)
1554 name = args[1].data.str.area;
1555
1556 sink = sink_find(name);
1557 if (!sink) {
1558 memprintf(err, "No such sink '%s'", name);
1559 return 0;
1560 }
1561
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001562 chunk_destroy(&args[1].data.str);
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001563 args[1].type = ARGT_PTR;
1564 args[1].data.ptr = sink;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001565 return 1;
1566}
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001567
Holger Just1bfc24b2017-05-06 00:56:53 +02001568static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1569{
Willy Tarreau83061a82018-07-13 11:56:34 +02001570 struct buffer *trash = get_trash_chunk();
Holger Just1bfc24b2017-05-06 00:56:53 +02001571 int bin_len;
1572
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001573 trash->data = 0;
1574 bin_len = base64dec(smp->data.u.str.area, smp->data.u.str.data,
1575 trash->area, trash->size);
Holger Just1bfc24b2017-05-06 00:56:53 +02001576 if (bin_len < 0)
1577 return 0;
1578
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001579 trash->data = bin_len;
Holger Just1bfc24b2017-05-06 00:56:53 +02001580 smp->data.u.str = *trash;
1581 smp->data.type = SMP_T_BIN;
1582 smp->flags &= ~SMP_F_CONST;
1583 return 1;
1584}
1585
Moemen MHEDHBI92f7d432021-04-01 20:53:59 +02001586static int sample_conv_base64url2bin(const struct arg *arg_p, struct sample *smp, void *private)
1587{
1588 struct buffer *trash = get_trash_chunk();
1589 int bin_len;
1590
1591 trash->data = 0;
1592 bin_len = base64urldec(smp->data.u.str.area, smp->data.u.str.data,
1593 trash->area, trash->size);
1594 if (bin_len < 0)
1595 return 0;
1596
1597 trash->data = bin_len;
1598 smp->data.u.str = *trash;
1599 smp->data.type = SMP_T_BIN;
1600 smp->flags &= ~SMP_F_CONST;
1601 return 1;
1602}
1603
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001604static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001605{
Willy Tarreau83061a82018-07-13 11:56:34 +02001606 struct buffer *trash = get_trash_chunk();
Emeric Brun53d1a982014-04-30 18:21:37 +02001607 int b64_len;
1608
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001609 trash->data = 0;
1610 b64_len = a2base64(smp->data.u.str.area, smp->data.u.str.data,
1611 trash->area, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001612 if (b64_len < 0)
1613 return 0;
1614
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001615 trash->data = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001616 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001617 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001618 smp->flags &= ~SMP_F_CONST;
1619 return 1;
1620}
1621
Moemen MHEDHBI92f7d432021-04-01 20:53:59 +02001622static int sample_conv_bin2base64url(const struct arg *arg_p, struct sample *smp, void *private)
1623{
1624 struct buffer *trash = get_trash_chunk();
1625 int b64_len;
1626
1627 trash->data = 0;
1628 b64_len = a2base64url(smp->data.u.str.area, smp->data.u.str.data,
1629 trash->area, trash->size);
1630 if (b64_len < 0)
1631 return 0;
1632
1633 trash->data = b64_len;
1634 smp->data.u.str = *trash;
1635 smp->data.type = SMP_T_STR;
1636 smp->flags &= ~SMP_F_CONST;
1637 return 1;
1638}
1639
Willy Tarreauea573502021-10-06 15:29:00 +02001640/* This function returns a sample struct filled with the conversion of variable
1641 * <var> to sample type <type> (SMP_T_*), via a cast to the target type. If the
1642 * variable cannot be retrieved or casted, 0 is returned, otherwise 1.
1643 *
1644 * Keep in mind that the sample content may be written to a pre-allocated
1645 * trash chunk as returned by get_trash_chunk().
1646 */
1647int sample_conv_var2smp(const struct var_desc *var, struct sample *smp, int type)
1648{
1649 if (!vars_get_by_desc(var, smp))
1650 return 0;
1651 if (!sample_casts[smp->data.type][type])
1652 return 0;
1653 if (!sample_casts[smp->data.type][type](smp))
1654 return 0;
1655 return 1;
1656}
1657
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001658static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1659{
1660 blk_SHA_CTX ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001661 struct buffer *trash = get_trash_chunk();
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001662
1663 memset(&ctx, 0, sizeof(ctx));
1664
1665 blk_SHA1_Init(&ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001666 blk_SHA1_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1667 blk_SHA1_Final((unsigned char *) trash->area, &ctx);
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001668
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001669 trash->data = 20;
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001670 smp->data.u.str = *trash;
1671 smp->data.type = SMP_T_BIN;
1672 smp->flags &= ~SMP_F_CONST;
1673 return 1;
1674}
1675
Tim Duesterhusd4376302019-06-17 12:41:44 +02001676#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01001677static int smp_check_sha2(struct arg *args, struct sample_conv *conv,
1678 const char *file, int line, char **err)
1679{
1680 if (args[0].type == ARGT_STOP)
1681 return 1;
1682 if (args[0].type != ARGT_SINT) {
1683 memprintf(err, "Invalid type '%s'", arg_type_names[args[0].type]);
1684 return 0;
1685 }
1686
1687 switch (args[0].data.sint) {
1688 case 224:
1689 case 256:
1690 case 384:
1691 case 512:
1692 /* this is okay */
1693 return 1;
1694 default:
1695 memprintf(err, "Unsupported number of bits: '%lld'", args[0].data.sint);
1696 return 0;
1697 }
1698}
1699
Tim Duesterhusd4376302019-06-17 12:41:44 +02001700static int sample_conv_sha2(const struct arg *arg_p, struct sample *smp, void *private)
1701{
1702 struct buffer *trash = get_trash_chunk();
1703 int bits = 256;
Christopher Faulete6e7a582021-01-29 11:29:28 +01001704 if (arg_p->data.sint)
Tim Duesterhusd4376302019-06-17 12:41:44 +02001705 bits = arg_p->data.sint;
1706
1707 switch (bits) {
1708 case 224: {
1709 SHA256_CTX ctx;
1710
1711 memset(&ctx, 0, sizeof(ctx));
1712
1713 SHA224_Init(&ctx);
1714 SHA224_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1715 SHA224_Final((unsigned char *) trash->area, &ctx);
1716 trash->data = SHA224_DIGEST_LENGTH;
1717 break;
1718 }
1719 case 256: {
1720 SHA256_CTX ctx;
1721
1722 memset(&ctx, 0, sizeof(ctx));
1723
1724 SHA256_Init(&ctx);
1725 SHA256_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1726 SHA256_Final((unsigned char *) trash->area, &ctx);
1727 trash->data = SHA256_DIGEST_LENGTH;
1728 break;
1729 }
1730 case 384: {
1731 SHA512_CTX ctx;
1732
1733 memset(&ctx, 0, sizeof(ctx));
1734
1735 SHA384_Init(&ctx);
1736 SHA384_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1737 SHA384_Final((unsigned char *) trash->area, &ctx);
1738 trash->data = SHA384_DIGEST_LENGTH;
1739 break;
1740 }
1741 case 512: {
1742 SHA512_CTX ctx;
1743
1744 memset(&ctx, 0, sizeof(ctx));
1745
1746 SHA512_Init(&ctx);
1747 SHA512_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1748 SHA512_Final((unsigned char *) trash->area, &ctx);
1749 trash->data = SHA512_DIGEST_LENGTH;
1750 break;
1751 }
1752 default:
1753 return 0;
1754 }
1755
1756 smp->data.u.str = *trash;
1757 smp->data.type = SMP_T_BIN;
1758 smp->flags &= ~SMP_F_CONST;
1759 return 1;
1760}
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001761
Dragan Dosen9e8db132021-02-22 10:03:53 +01001762/* This function returns a sample struct filled with an <arg> content.
1763 * If the <arg> contains a string, it is returned in the sample flagged as
1764 * SMP_F_CONST. If the <arg> contains a variable descriptor, the sample is
1765 * filled with the content of the variable by using vars_get_by_desc().
1766 *
1767 * Keep in mind that the sample content may be written to a pre-allocated
1768 * trash chunk as returned by get_trash_chunk().
1769 *
1770 * This function returns 0 if an error occurs, otherwise it returns 1.
1771 */
Willy Tarreau05cd2e62021-10-06 15:20:18 +02001772int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001773{
1774 switch (arg->type) {
1775 case ARGT_STR:
1776 smp->data.type = SMP_T_STR;
1777 smp->data.u.str = arg->data.str;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001778 smp->flags = SMP_F_CONST;
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001779 return 1;
1780 case ARGT_VAR:
Willy Tarreau8fdaf252021-10-06 15:30:52 +02001781 return sample_conv_var2smp(&arg->data.var, smp, SMP_T_STR);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001782 default:
1783 return 0;
1784 }
1785}
1786
Dragan Dosen9e8db132021-02-22 10:03:53 +01001787/* This function checks an <arg> and fills it with a variable type if the
1788 * <arg> string contains a valid variable name. If failed, the function
1789 * tries to perform a base64 decode operation on the same string, and
1790 * fills the <arg> with the decoded content.
1791 *
1792 * Validation is skipped if the <arg> string is empty.
1793 *
1794 * This function returns 0 if the variable lookup fails and the specified
1795 * <arg> string is not a valid base64 encoded string, as well if
1796 * unexpected argument type is specified or memory allocation error
1797 * occurs. Otherwise it returns 1.
1798 */
1799static inline int sample_check_arg_base64(struct arg *arg, char **err)
1800{
1801 char *dec = NULL;
1802 int dec_size;
1803
1804 if (arg->type != ARGT_STR) {
1805 memprintf(err, "unexpected argument type");
1806 return 0;
1807 }
1808
1809 if (arg->data.str.data == 0) /* empty */
1810 return 1;
1811
1812 if (vars_check_arg(arg, NULL))
1813 return 1;
1814
1815 if (arg->data.str.data % 4) {
1816 memprintf(err, "argument needs to be base64 encoded, and "
1817 "can either be a string or a variable");
1818 return 0;
1819 }
1820
1821 dec_size = (arg->data.str.data / 4 * 3)
1822 - (arg->data.str.area[arg->data.str.data-1] == '=' ? 1 : 0)
1823 - (arg->data.str.area[arg->data.str.data-2] == '=' ? 1 : 0);
1824
1825 if ((dec = malloc(dec_size)) == NULL) {
1826 memprintf(err, "memory allocation error");
1827 return 0;
1828 }
1829
1830 dec_size = base64dec(arg->data.str.area, arg->data.str.data, dec, dec_size);
1831 if (dec_size < 0) {
1832 memprintf(err, "argument needs to be base64 encoded, and "
1833 "can either be a string or a variable");
1834 free(dec);
1835 return 0;
1836 }
1837
1838 /* base64 decoded */
1839 chunk_destroy(&arg->data.str);
1840 arg->data.str.area = dec;
1841 arg->data.str.data = dec_size;
1842 return 1;
1843}
1844
Ilya Shipitsin2c481d02021-03-26 23:35:31 +05001845#ifdef EVP_CIPH_GCM_MODE
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001846static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
1847 const char *file, int line, char **err)
1848{
1849 switch(args[0].data.sint) {
1850 case 128:
1851 case 192:
1852 case 256:
1853 break;
1854 default:
1855 memprintf(err, "key size must be 128, 192 or 256 (bits).");
1856 return 0;
1857 }
Dragan Dosen9e8db132021-02-22 10:03:53 +01001858
1859 /* Try to decode variables. */
1860 if (!sample_check_arg_base64(&args[1], err)) {
1861 memprintf(err, "failed to parse nonce : %s", *err);
1862 return 0;
1863 }
1864 if (!sample_check_arg_base64(&args[2], err)) {
1865 memprintf(err, "failed to parse key : %s", *err);
1866 return 0;
1867 }
1868 if (!sample_check_arg_base64(&args[3], err)) {
1869 memprintf(err, "failed to parse aead_tag : %s", *err);
1870 return 0;
1871 }
1872
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001873 return 1;
1874}
1875
1876/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
1877static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
1878{
1879 struct sample nonce, key, aead_tag;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001880 struct buffer *smp_trash = NULL, *smp_trash_alloc = NULL;
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001881 EVP_CIPHER_CTX *ctx;
1882 int dec_size, ret;
1883
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001884 smp_trash_alloc = alloc_trash_chunk();
1885 if (!smp_trash_alloc)
1886 return 0;
1887
Dragan Dosen9e8db132021-02-22 10:03:53 +01001888 /* smp copy */
1889 smp_trash_alloc->data = smp->data.u.str.data;
1890 if (unlikely(smp_trash_alloc->data > smp_trash_alloc->size))
1891 smp_trash_alloc->data = smp_trash_alloc->size;
1892 memcpy(smp_trash_alloc->area, smp->data.u.str.area, smp_trash_alloc->data);
1893
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001894 ctx = EVP_CIPHER_CTX_new();
1895
1896 if (!ctx)
1897 goto err;
1898
Dragan Dosen9e8db132021-02-22 10:03:53 +01001899 smp_trash = alloc_trash_chunk();
1900 if (!smp_trash)
1901 goto err;
1902
1903 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
1904 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001905 goto err;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001906
1907 if (arg_p[1].type == ARGT_VAR) {
1908 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
1909 if (dec_size < 0)
1910 goto err;
1911 smp_trash->data = dec_size;
1912 nonce.data.u.str = *smp_trash;
1913 }
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001914
1915 /* Set cipher type and mode */
1916 switch(arg_p[0].data.sint) {
1917 case 128:
1918 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
1919 break;
1920 case 192:
1921 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
1922 break;
1923 case 256:
1924 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
1925 break;
1926 }
1927
Dragan Dosen9e8db132021-02-22 10:03:53 +01001928 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, nonce.data.u.str.data, NULL);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001929
1930 /* Initialise IV */
Dragan Dosen9e8db132021-02-22 10:03:53 +01001931 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) nonce.data.u.str.area))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001932 goto err;
1933
Dragan Dosen9e8db132021-02-22 10:03:53 +01001934 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1935 if (!sample_conv_var2smp_str(&arg_p[2], &key))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001936 goto err;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001937
1938 if (arg_p[2].type == ARGT_VAR) {
1939 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
1940 if (dec_size < 0)
1941 goto err;
1942 smp_trash->data = dec_size;
1943 key.data.u.str = *smp_trash;
1944 }
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001945
1946 /* Initialise key */
Dragan Dosen9e8db132021-02-22 10:03:53 +01001947 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) key.data.u.str.area, NULL))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001948 goto err;
1949
1950 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
Dragan Dosen9e8db132021-02-22 10:03:53 +01001951 (unsigned char *) smp_trash_alloc->area, (int) smp_trash_alloc->data))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001952 goto err;
1953
Dragan Dosen9e8db132021-02-22 10:03:53 +01001954 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
1955 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001956 goto err;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001957
1958 if (arg_p[3].type == ARGT_VAR) {
1959 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
1960 if (dec_size < 0)
1961 goto err;
1962 smp_trash_alloc->data = dec_size;
1963 aead_tag.data.u.str = *smp_trash_alloc;
1964 }
1965
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001966 dec_size = smp_trash->data;
1967
Dragan Dosen9e8db132021-02-22 10:03:53 +01001968 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 +02001969 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
1970
1971 if (ret <= 0)
1972 goto err;
1973
1974 smp->data.u.str.data = dec_size + smp_trash->data;
1975 smp->data.u.str.area = smp_trash->area;
1976 smp->data.type = SMP_T_BIN;
Dragan Dosen9e8db132021-02-22 10:03:53 +01001977 smp_dup(smp);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001978 free_trash_chunk(smp_trash_alloc);
Dragan Dosen9e8db132021-02-22 10:03:53 +01001979 free_trash_chunk(smp_trash);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001980 return 1;
1981
1982err:
1983 free_trash_chunk(smp_trash_alloc);
Dragan Dosen9e8db132021-02-22 10:03:53 +01001984 free_trash_chunk(smp_trash);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001985 return 0;
1986}
Ilya Shipitsin2c481d02021-03-26 23:35:31 +05001987#endif
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001988
Patrick Gansterer8e366512020-04-22 16:47:57 +02001989static int check_crypto_digest(struct arg *args, struct sample_conv *conv,
1990 const char *file, int line, char **err)
1991{
1992 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1993
1994 if (evp)
1995 return 1;
1996
1997 memprintf(err, "algorithm must be a valid OpenSSL message digest name.");
1998 return 0;
1999}
2000
2001static int sample_conv_crypto_digest(const struct arg *args, struct sample *smp, void *private)
2002{
2003 struct buffer *trash = get_trash_chunk();
2004 unsigned char *md = (unsigned char*) trash->area;
2005 unsigned int md_len = trash->size;
2006 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
2007 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
2008
2009 if (!ctx)
2010 return 0;
2011
2012 if (!EVP_DigestInit_ex(ctx, evp, NULL) ||
2013 !EVP_DigestUpdate(ctx, smp->data.u.str.area, smp->data.u.str.data) ||
2014 !EVP_DigestFinal_ex(ctx, md, &md_len)) {
2015 EVP_MD_CTX_free(ctx);
2016 return 0;
2017 }
2018
2019 EVP_MD_CTX_free(ctx);
2020
2021 trash->data = md_len;
2022 smp->data.u.str = *trash;
2023 smp->data.type = SMP_T_BIN;
2024 smp->flags &= ~SMP_F_CONST;
2025 return 1;
2026}
2027
2028static int check_crypto_hmac(struct arg *args, struct sample_conv *conv,
2029 const char *file, int line, char **err)
2030{
2031 if (!check_crypto_digest(args, conv, file, line, err))
2032 return 0;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002033
2034 if (!sample_check_arg_base64(&args[1], err)) {
2035 memprintf(err, "failed to parse key : %s", *err);
2036 return 0;
2037 }
Patrick Gansterer8e366512020-04-22 16:47:57 +02002038
Patrick Gansterer8e366512020-04-22 16:47:57 +02002039 return 1;
2040}
2041
2042static int sample_conv_crypto_hmac(const struct arg *args, struct sample *smp, void *private)
2043{
2044 struct sample key;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002045 struct buffer *trash = NULL, *key_trash = NULL;
Patrick Gansterer8e366512020-04-22 16:47:57 +02002046 unsigned char *md;
2047 unsigned int md_len;
2048 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
2049 int dec_size;
2050
2051 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
2052 if (!sample_conv_var2smp_str(&args[1], &key))
2053 return 0;
2054
Dragan Dosen9e8db132021-02-22 10:03:53 +01002055 if (args[1].type == ARGT_VAR) {
2056 key_trash = alloc_trash_chunk();
2057 if (!key_trash)
2058 goto err;
2059
2060 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, key_trash->area, key_trash->size);
2061 if (dec_size < 0)
2062 goto err;
2063 key_trash->data = dec_size;
2064 key.data.u.str = *key_trash;
2065 }
Patrick Gansterer8e366512020-04-22 16:47:57 +02002066
Dragan Dosen9e8db132021-02-22 10:03:53 +01002067 trash = alloc_trash_chunk();
2068 if (!trash)
Patrick Gansterer8e366512020-04-22 16:47:57 +02002069 goto err;
2070
2071 md = (unsigned char*) trash->area;
2072 md_len = trash->size;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002073 if (!HMAC(evp, key.data.u.str.area, key.data.u.str.data, (const unsigned char*) smp->data.u.str.area,
2074 smp->data.u.str.data, md, &md_len))
Patrick Gansterer8e366512020-04-22 16:47:57 +02002075 goto err;
2076
2077 free_trash_chunk(key_trash);
2078
2079 trash->data = md_len;
2080 smp->data.u.str = *trash;
2081 smp->data.type = SMP_T_BIN;
Dragan Dosen9e8db132021-02-22 10:03:53 +01002082 smp_dup(smp);
2083 free_trash_chunk(trash);
Patrick Gansterer8e366512020-04-22 16:47:57 +02002084 return 1;
2085
2086err:
2087 free_trash_chunk(key_trash);
Dragan Dosen9e8db132021-02-22 10:03:53 +01002088 free_trash_chunk(trash);
Patrick Gansterer8e366512020-04-22 16:47:57 +02002089 return 0;
2090}
2091
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02002092#endif /* USE_OPENSSL */
Tim Duesterhusd4376302019-06-17 12:41:44 +02002093
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002094static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002095{
Willy Tarreau83061a82018-07-13 11:56:34 +02002096 struct buffer *trash = get_trash_chunk();
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002097 unsigned char c;
2098 int ptr = 0;
2099
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002100 trash->data = 0;
2101 while (ptr < smp->data.u.str.data && trash->data <= trash->size - 2) {
2102 c = smp->data.u.str.area[ptr++];
2103 trash->area[trash->data++] = hextab[(c >> 4) & 0xF];
2104 trash->area[trash->data++] = hextab[c & 0xF];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002105 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002106 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002107 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002108 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002109 return 1;
2110}
2111
Dragan Dosen3f957b22017-10-24 09:27:34 +02002112static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
2113{
2114 long long int n = 0;
2115 int i, c;
2116
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002117 for (i = 0; i < smp->data.u.str.data; i++) {
2118 if ((c = hex2i(smp->data.u.str.area[i])) < 0)
Dragan Dosen3f957b22017-10-24 09:27:34 +02002119 return 0;
2120 n = (n << 4) + c;
2121 }
2122
2123 smp->data.u.sint = n;
2124 smp->data.type = SMP_T_SINT;
2125 smp->flags &= ~SMP_F_CONST;
2126 return 1;
2127}
2128
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002129/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002130static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002131{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002132 smp->data.u.sint = hash_djb2(smp->data.u.str.area,
2133 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002134 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002135 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002136 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002137 return 1;
2138}
2139
Willy Tarreau60a2ee72017-12-15 07:13:48 +01002140static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01002141{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002142 int i = smp->data.u.str.data;
Etienne Carriereed0d24e2017-12-13 13:41:34 +01002143 smp->data.u.sint = i;
2144 smp->data.type = SMP_T_SINT;
2145 return 1;
2146}
2147
2148
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002149static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01002150{
2151 int i;
2152
Willy Tarreauf0645dc2016-08-09 14:29:38 +02002153 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002154 return 0;
2155
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002156 for (i = 0; i < smp->data.u.str.data; i++) {
2157 if ((smp->data.u.str.area[i] >= 'A') && (smp->data.u.str.area[i] <= 'Z'))
2158 smp->data.u.str.area[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01002159 }
2160 return 1;
2161}
2162
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002163static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01002164{
2165 int i;
2166
Willy Tarreauf0645dc2016-08-09 14:29:38 +02002167 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02002168 return 0;
2169
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002170 for (i = 0; i < smp->data.u.str.data; i++) {
2171 if ((smp->data.u.str.area[i] >= 'a') && (smp->data.u.str.area[i] <= 'z'))
2172 smp->data.u.str.area[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01002173 }
2174 return 1;
2175}
2176
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002177/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
2178static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01002179{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002180 /* Attempt to convert to IPv4 to apply the correct mask. */
2181 c_ipv62ip(smp);
2182
2183 if (smp->data.type == SMP_T_IPV4) {
2184 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
2185 smp->data.type = SMP_T_IPV4;
2186 }
2187 else if (smp->data.type == SMP_T_IPV6) {
2188 /* IPv6 cannot be converted without an IPv6 mask. */
2189 if (args[1].type != ARGT_IPV6)
2190 return 0;
2191
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +01002192 write_u64(&smp->data.u.ipv6.s6_addr[0],
2193 read_u64(&smp->data.u.ipv6.s6_addr[0]) & read_u64(&args[1].data.ipv6.s6_addr[0]));
2194 write_u64(&smp->data.u.ipv6.s6_addr[8],
2195 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 +01002196 smp->data.type = SMP_T_IPV6;
2197 }
2198
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01002199 return 1;
2200}
2201
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002202/* takes an UINT value on input supposed to represent the time since EPOCH,
2203 * adds an optional offset found in args[1] and emits a string representing
2204 * the local time in the format specified in args[1] using strftime().
2205 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002206static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002207{
Willy Tarreau83061a82018-07-13 11:56:34 +02002208 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002209 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002210 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Tim Duesterhus9da4b1f2021-08-28 23:57:01 +02002211 struct tm tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002212
2213 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002214 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002215 curr_date += args[1].data.sint;
2216
Tim Duesterhus9da4b1f2021-08-28 23:57:01 +02002217 get_localtime(curr_date, &tm);
2218
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002219 temp = get_trash_chunk();
Tim Duesterhus9da4b1f2021-08-28 23:57:01 +02002220 temp->data = strftime(temp->area, temp->size, args[0].data.str.area, &tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002221 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002222 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002223 return 1;
2224}
2225
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002226/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002227static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002228{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002229 smp->data.u.sint = hash_sdbm(smp->data.u.str.area,
2230 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002231 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002232 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002233 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002234 return 1;
2235}
2236
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002237/* takes an UINT value on input supposed to represent the time since EPOCH,
2238 * adds an optional offset found in args[1] and emits a string representing
2239 * the UTC date in the format specified in args[1] using strftime().
2240 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002241static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002242{
Willy Tarreau83061a82018-07-13 11:56:34 +02002243 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002244 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002245 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Tim Duesterhus9da4b1f2021-08-28 23:57:01 +02002246 struct tm tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002247
2248 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002249 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002250 curr_date += args[1].data.sint;
2251
Tim Duesterhus9da4b1f2021-08-28 23:57:01 +02002252 get_gmtime(curr_date, &tm);
2253
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002254 temp = get_trash_chunk();
Tim Duesterhus9da4b1f2021-08-28 23:57:01 +02002255 temp->data = strftime(temp->area, temp->size, args[0].data.str.area, &tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002256 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002257 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002258 return 1;
2259}
2260
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002261/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002262static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002263{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002264 smp->data.u.sint = hash_wt6(smp->data.u.str.area,
2265 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002266 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002267 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002268 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002269 return 1;
2270}
2271
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002272/* hashes the binary input into a 32-bit unsigned int using xxh.
2273 * The seed of the hash defaults to 0 but can be changd in argument 1.
2274 */
2275static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
2276{
2277 unsigned int seed;
2278
Christopher Faulete6e7a582021-01-29 11:29:28 +01002279 if (arg_p->data.sint)
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002280 seed = arg_p->data.sint;
2281 else
2282 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002283 smp->data.u.sint = XXH32(smp->data.u.str.area, smp->data.u.str.data,
2284 seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002285 smp->data.type = SMP_T_SINT;
2286 return 1;
2287}
2288
2289/* hashes the binary input into a 64-bit unsigned int using xxh.
2290 * In fact, the function returns a 64 bit unsigned, but the sample
2291 * storage of haproxy only proposes 64-bits signed, so the value is
2292 * cast as signed. This cast doesn't impact the hash repartition.
2293 * The seed of the hash defaults to 0 but can be changd in argument 1.
2294 */
2295static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
2296{
2297 unsigned long long int seed;
2298
Christopher Faulete6e7a582021-01-29 11:29:28 +01002299 if (arg_p->data.sint)
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002300 seed = (unsigned long long int)arg_p->data.sint;
2301 else
2302 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002303 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.area,
2304 smp->data.u.str.data, seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002305 smp->data.type = SMP_T_SINT;
2306 return 1;
2307}
2308
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01002309static int sample_conv_xxh3(const struct arg *arg_p, struct sample *smp, void *private)
2310{
2311 unsigned long long int seed;
2312
Christopher Faulete6e7a582021-01-29 11:29:28 +01002313 if (arg_p->data.sint)
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01002314 seed = (unsigned long long int)arg_p->data.sint;
2315 else
2316 seed = 0;
2317 smp->data.u.sint = (long long int)XXH3(smp->data.u.str.area,
2318 smp->data.u.str.data, seed);
2319 smp->data.type = SMP_T_SINT;
2320 return 1;
2321}
2322
Willy Tarreau80599772015-01-20 19:35:24 +01002323/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002324static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002325{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002326 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2327 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002328 if (arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002329 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002330 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002331 return 1;
2332}
2333
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002334/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2335static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2336{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002337 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2338 smp->data.u.str.data);
Christopher Faulete6e7a582021-01-29 11:29:28 +01002339 if (arg_p->data.sint)
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002340 smp->data.u.sint = full_hash(smp->data.u.sint);
2341 smp->data.type = SMP_T_SINT;
2342 return 1;
2343}
2344
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002345/* This function escape special json characters. The returned string can be
2346 * safely set between two '"' and used as json string. The json string is
2347 * defined like this:
2348 *
2349 * any Unicode character except '"' or '\' or control character
2350 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2351 *
2352 * The enum input_type contain all the allowed mode for decoding the input
2353 * string.
2354 */
2355enum input_type {
2356 IT_ASCII = 0,
2357 IT_UTF8,
2358 IT_UTF8S,
2359 IT_UTF8P,
2360 IT_UTF8PS,
2361};
William Dauchy5417e892021-01-08 21:57:41 +01002362
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002363static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2364 const char *file, int line, char **err)
2365{
Christopher Faulet95917132020-08-05 23:07:07 +02002366 enum input_type type;
2367
Christopher Faulet95917132020-08-05 23:07:07 +02002368 if (strcmp(arg->data.str.area, "") == 0)
2369 type = IT_ASCII;
2370 else if (strcmp(arg->data.str.area, "ascii") == 0)
2371 type = IT_ASCII;
2372 else if (strcmp(arg->data.str.area, "utf8") == 0)
2373 type = IT_UTF8;
2374 else if (strcmp(arg->data.str.area, "utf8s") == 0)
2375 type = IT_UTF8S;
2376 else if (strcmp(arg->data.str.area, "utf8p") == 0)
2377 type = IT_UTF8P;
2378 else if (strcmp(arg->data.str.area, "utf8ps") == 0)
2379 type = IT_UTF8PS;
2380 else {
2381 memprintf(err, "Unexpected input code type. "
2382 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
2383 return 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002384 }
2385
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002386 chunk_destroy(&arg->data.str);
Christopher Faulet95917132020-08-05 23:07:07 +02002387 arg->type = ARGT_SINT;
2388 arg->data.sint = type;
2389 return 1;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002390}
2391
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002392static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002393{
Willy Tarreau83061a82018-07-13 11:56:34 +02002394 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002395 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2396 const char *str;
2397 int len;
2398 enum input_type input_type = IT_ASCII;
2399 unsigned int c;
2400 unsigned int ret;
2401 char *p;
2402
Christopher Faulete6e7a582021-01-29 11:29:28 +01002403 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002404
2405 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002406 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002407
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002408 p = smp->data.u.str.area;
2409 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002410
2411 if (input_type == IT_ASCII) {
2412 /* Read input as ASCII. */
2413 c = *(unsigned char *)p;
2414 p++;
2415 }
2416 else {
2417 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002418 ret = utf8_next(p,
2419 smp->data.u.str.data - ( p - smp->data.u.str.area),
2420 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002421 p += utf8_return_length(ret);
2422
2423 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2424 return 0;
2425 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2426 continue;
2427 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2428 return 0;
2429 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2430 continue;
2431
2432 /* Check too big values. */
2433 if ((unsigned int)c > 0xffff) {
2434 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2435 return 0;
2436 continue;
2437 }
2438 }
2439
2440 /* Convert character. */
2441 if (c == '"') {
2442 len = 2;
2443 str = "\\\"";
2444 }
2445 else if (c == '\\') {
2446 len = 2;
2447 str = "\\\\";
2448 }
2449 else if (c == '/') {
2450 len = 2;
2451 str = "\\/";
2452 }
2453 else if (c == '\b') {
2454 len = 2;
2455 str = "\\b";
2456 }
2457 else if (c == '\f') {
2458 len = 2;
2459 str = "\\f";
2460 }
2461 else if (c == '\r') {
2462 len = 2;
2463 str = "\\r";
2464 }
2465 else if (c == '\n') {
2466 len = 2;
2467 str = "\\n";
2468 }
2469 else if (c == '\t') {
2470 len = 2;
2471 str = "\\t";
2472 }
Willy Tarreau90807112020-02-25 08:16:33 +01002473 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002474 /* isprint generate a segfault if c is too big. The man says that
2475 * c must have the value of an unsigned char or EOF.
2476 */
2477 len = 6;
2478 _str[0] = '\\';
2479 _str[1] = 'u';
2480 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2481 str = _str;
2482 }
2483 else {
2484 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002485 _str[0] = c;
2486 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002487 }
2488
2489 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002490 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002491 return 0;
2492
2493 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002494 memcpy(temp->area + temp->data, str, len);
2495 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002496 }
2497
2498 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002499 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002500 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002501
2502 return 1;
2503}
2504
Emeric Brun54c4ac82014-11-03 15:32:43 +01002505/* This sample function is designed to extract some bytes from an input buffer.
2506 * First arg is the offset.
2507 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002508static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002509{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002510 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2511 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002512 return 1;
2513 }
2514
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002515 if (smp->data.u.str.size)
2516 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002517 smp->data.u.str.data -= arg_p[0].data.sint;
2518 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002519
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002520 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2521 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002522
2523 return 1;
2524}
2525
Emeric Brunf399b0d2014-11-03 17:07:03 +01002526static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2527 const char *file, int line, char **err)
2528{
2529 struct arg *arg = args;
2530
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002531 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002532 memprintf(err, "Unexpected arg type");
2533 return 0;
2534 }
2535
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002536 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002537 memprintf(err, "Unexpected value 0 for index");
2538 return 0;
2539 }
2540
2541 arg++;
2542
2543 if (arg->type != ARGT_STR) {
2544 memprintf(err, "Unexpected arg type");
2545 return 0;
2546 }
2547
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002548 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002549 memprintf(err, "Empty separators list");
2550 return 0;
2551 }
2552
2553 return 1;
2554}
2555
2556/* This sample function is designed to a return selected part of a string (field).
2557 * First arg is the index of the field (start at 1)
2558 * Second arg is a char list of separators (type string)
2559 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002560static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002561{
Marcin Deranek9631a282018-04-16 14:30:46 +02002562 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002563 char *start, *end;
2564 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002565 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002566
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002567 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002568 return 0;
2569
Marcin Deranek9631a282018-04-16 14:30:46 +02002570 if (arg_p[0].data.sint < 0) {
2571 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002572 end = start = smp->data.u.str.area + smp->data.u.str.data;
2573 while (start > smp->data.u.str.area) {
2574 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2575 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002576 if (field == arg_p[0].data.sint) {
2577 if (count == 1)
2578 goto found;
2579 else if (count > 1)
2580 count--;
2581 } else {
2582 end = start-1;
2583 field--;
2584 }
2585 break;
2586 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002587 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002588 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002589 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002590 } else {
2591 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002592 end = start = smp->data.u.str.area;
2593 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2594 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2595 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002596 if (field == arg_p[0].data.sint) {
2597 if (count == 1)
2598 goto found;
2599 else if (count > 1)
2600 count--;
2601 } else {
2602 start = end+1;
2603 field++;
2604 }
2605 break;
2606 }
2607 }
2608 end++;
2609 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002610 }
2611
2612 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002613 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002614 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002615 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002616 }
2617found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002618 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002619 /* If ret string is len 0, no need to
2620 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002621 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002622 return 1;
2623
Emeric Brunf399b0d2014-11-03 17:07:03 +01002624 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002625 Note: smp->data.u.str.size cannot be set to 0 */
2626 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002627 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002628
Thayne McCombsb2843052021-04-11 23:26:59 -06002629 smp->data.u.str.area = start;
2630
Emeric Brunf399b0d2014-11-03 17:07:03 +01002631 return 1;
2632}
2633
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002634/* This sample function is designed to return a word from a string.
2635 * First arg is the index of the word (start at 1)
2636 * Second arg is a char list of words separators (type string)
2637 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002638static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002639{
Marcin Deranek9631a282018-04-16 14:30:46 +02002640 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002641 char *start, *end;
2642 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002643 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002644
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002645 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002646 return 0;
2647
2648 word = 0;
2649 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002650 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002651 end = start = smp->data.u.str.area + smp->data.u.str.data;
2652 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002653 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002654 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2655 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002656 issep = 1;
2657 break;
2658 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002659 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002660 if (!inword) {
2661 if (!issep) {
2662 if (word != arg_p[0].data.sint) {
2663 word--;
2664 end = start;
2665 }
2666 inword = 1;
2667 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002668 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002669 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002670 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002671 if (count == 1)
2672 goto found;
2673 else if (count > 1)
2674 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002675 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002676 inword = 0;
2677 }
2678 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002679 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002680 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002681 end = start = smp->data.u.str.area;
2682 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002683 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002684 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2685 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002686 issep = 1;
2687 break;
2688 }
2689 }
2690 if (!inword) {
2691 if (!issep) {
2692 if (word != arg_p[0].data.sint) {
2693 word++;
2694 start = end;
2695 }
2696 inword = 1;
2697 }
2698 }
2699 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002700 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002701 if (count == 1)
2702 goto found;
2703 else if (count > 1)
2704 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002705 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002706 inword = 0;
2707 }
2708 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002709 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002710 }
2711
2712 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002713 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002714 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002715 return 1;
2716 }
2717found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002718 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002719 /* If ret string is len 0, no need to
2720 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002721 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002722 return 1;
2723
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002724
2725 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002726 Note: smp->data.u.str.size cannot be set to 0 */
2727 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002728 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002729
Thayne McCombsdaa8cd12022-05-25 22:58:51 -06002730 smp->data.u.str.area = start;
2731
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002732 return 1;
2733}
2734
Willy Tarreau7eda8492015-01-20 19:47:06 +01002735static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2736 const char *file, int line, char **err)
2737{
2738 struct arg *arg = args;
2739 char *p;
2740 int len;
2741
2742 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2743 arg[0].type_flags = 0;
2744
2745 if (arg[2].type != ARGT_STR)
2746 return 1;
2747
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002748 p = arg[2].data.str.area;
2749 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002750 while (len) {
2751 if (*p == 'i') {
2752 arg[0].type_flags |= ARGF_REG_ICASE;
2753 }
2754 else if (*p == 'g') {
2755 arg[0].type_flags |= ARGF_REG_GLOB;
2756 }
2757 else {
2758 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2759 return 0;
2760 }
2761 p++;
2762 len--;
2763 }
2764 return 1;
2765}
2766
2767/* This sample function is designed to do the equivalent of s/match/replace/ on
2768 * the input string. It applies a regex and restarts from the last matched
2769 * location until nothing matches anymore. First arg is the regex to apply to
2770 * the input string, second arg is the replacement expression.
2771 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002772static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002773{
2774 char *start, *end;
2775 struct my_regex *reg = arg_p[0].data.reg;
2776 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002777 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002778 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002779 int flag, max;
2780 int found;
2781
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002782 start = smp->data.u.str.area;
2783 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002784
2785 flag = 0;
2786 while (1) {
2787 /* check for last round which is used to copy remaining parts
2788 * when not running in global replacement mode.
2789 */
2790 found = 0;
2791 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2792 /* Note: we can have start == end on empty strings or at the end */
2793 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2794 }
2795
2796 if (!found)
2797 pmatch[0].rm_so = end - start;
2798
2799 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002800 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002801 if (max && pmatch[0].rm_so > 0) {
2802 if (max > pmatch[0].rm_so)
2803 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002804 memcpy(trash->area + trash->data, start, max);
2805 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002806 }
2807
2808 if (!found)
2809 break;
2810
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002811 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002812 if (!output)
2813 break;
2814
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002815 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2816
Willy Tarreau7eda8492015-01-20 19:47:06 +01002817 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002818 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002819 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002820 if (max > output->data)
2821 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002822 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002823 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002824 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002825 }
2826
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002827 free_trash_chunk(output);
2828
Willy Tarreau7eda8492015-01-20 19:47:06 +01002829 /* stop here if we're done with this string */
2830 if (start >= end)
2831 break;
2832
2833 /* We have a special case for matches of length 0 (eg: "x*y*").
2834 * These ones are considered to match in front of a character,
2835 * so we have to copy that character and skip to the next one.
2836 */
2837 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002838 if (trash->data < trash->size)
2839 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002840 pmatch[0].rm_eo++;
2841 }
2842
2843 start += pmatch[0].rm_eo;
2844 flag |= REG_NOTBOL;
2845 }
2846
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002847 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002848 return 1;
2849}
2850
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002851/* This function check an operator entry. It expects a string.
2852 * The string can be an integer or a variable name.
2853 */
2854static int check_operator(struct arg *args, struct sample_conv *conv,
2855 const char *file, int line, char **err)
2856{
2857 const char *str;
2858 const char *end;
Christopher Faulet95917132020-08-05 23:07:07 +02002859 long long int i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002860
2861 /* Try to decode a variable. */
2862 if (vars_check_arg(&args[0], NULL))
2863 return 1;
2864
2865 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002866 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002867 end = str + strlen(str);
Christopher Faulet95917132020-08-05 23:07:07 +02002868 i = read_int64(&str, end);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002869 if (*str != '\0') {
2870 memprintf(err, "expects an integer or a variable name");
2871 return 0;
2872 }
Christopher Faulet95917132020-08-05 23:07:07 +02002873
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002874 chunk_destroy(&args[0].data.str);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002875 args[0].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02002876 args[0].data.sint = i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002877 return 1;
2878}
2879
Willy Tarreau6204cd92016-03-10 16:33:04 +01002880/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002881 * If the arg contain an integer, the integer is returned in the
2882 * sample. If the arg contains a variable descriptor, it returns the
2883 * variable value.
2884 *
2885 * This function returns 0 if an error occurs, otherwise it returns 1.
2886 */
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02002887int sample_conv_var2smp_sint(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002888{
2889 switch (arg->type) {
2890 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002891 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002892 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002893 return 1;
2894 case ARGT_VAR:
Willy Tarreau8fdaf252021-10-06 15:30:52 +02002895 return sample_conv_var2smp(&arg->data.var, smp, SMP_T_SINT);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002896 default:
2897 return 0;
2898 }
2899}
2900
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002901/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002902 * result.
2903 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002904static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002905{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002906 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002907 return 1;
2908}
2909
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002910/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002911 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002912 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002913static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002914{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002915 struct sample tmp;
2916
Willy Tarreau7560dd42016-03-10 16:28:58 +01002917 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02002918 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002919 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002920 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002921 return 1;
2922}
2923
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002924/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002925 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002926 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002927static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002928{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002929 struct sample tmp;
2930
Willy Tarreau7560dd42016-03-10 16:28:58 +01002931 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02002932 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002933 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002934 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002935 return 1;
2936}
2937
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002938/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002939 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002940 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002941static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002942{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002943 struct sample tmp;
2944
Willy Tarreau7560dd42016-03-10 16:28:58 +01002945 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02002946 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002947 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002948 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002949 return 1;
2950}
2951
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002952static inline long long int arith_add(long long int a, long long int b)
2953{
2954 /* Prevent overflow and makes capped calculus.
2955 * We must ensure that the check calculus doesn't
2956 * exceed the signed 64 bits limits.
2957 *
2958 * +----------+----------+
2959 * | a<0 | a>=0 |
2960 * +------+----------+----------+
2961 * | b<0 | MIN-a>b | no check |
2962 * +------+----------+----------+
2963 * | b>=0 | no check | MAX-a<b |
2964 * +------+----------+----------+
2965 */
2966 if ((a ^ b) >= 0) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002967 /* signs are different. */
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002968 if (a < 0) {
2969 if (LLONG_MIN - a > b)
2970 return LLONG_MIN;
2971 }
2972 if (LLONG_MAX - a < b)
2973 return LLONG_MAX;
2974 }
2975 return a + b;
2976}
2977
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002978/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002979 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002980 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002981static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002982{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002983 struct sample tmp;
2984
Willy Tarreau7560dd42016-03-10 16:28:58 +01002985 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02002986 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002987 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002988 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002989 return 1;
2990}
2991
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002992/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002993 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002994 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002995static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002996 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002997{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002998 struct sample tmp;
2999
Willy Tarreau7560dd42016-03-10 16:28:58 +01003000 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02003001 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003002 return 0;
3003
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003004 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
3005 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
3006 * of -LLONG_MIN and correct the result.
3007 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003008 if (tmp.data.u.sint == LLONG_MIN) {
3009 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
3010 if (smp->data.u.sint < LLONG_MAX)
3011 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003012 return 1;
3013 }
3014
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003015 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003016 * the second operand.
3017 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003018 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01003019 return 1;
3020}
3021
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003022/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003023 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003024 * If the result makes an overflow, then the largest possible quantity is
3025 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003026 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003027static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003028 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003029{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003030 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003031 long long int c;
3032
Willy Tarreau7560dd42016-03-10 16:28:58 +01003033 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02003034 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003035 return 0;
3036
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003037 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003038 if (!smp->data.u.sint || !tmp.data.u.sint) {
3039 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003040 return 1;
3041 }
3042
3043 /* The multiply between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003044 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003045 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003046 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3047 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003048 return 1;
3049 }
3050
3051 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003052 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003053
3054 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003055 if (smp->data.u.sint != c / tmp.data.u.sint) {
3056 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
3057 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003058 return 1;
3059 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003060 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003061 return 1;
3062 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003063 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01003064 return 1;
3065}
3066
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003067/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003068 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003069 * If arg_p makes the result overflow, then the largest possible quantity is
3070 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003071 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003072static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003073 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003074{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003075 struct sample tmp;
3076
Willy Tarreau7560dd42016-03-10 16:28:58 +01003077 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02003078 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003079 return 0;
3080
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003081 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003082 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003083 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003084 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003085 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3086 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003087 return 1;
3088 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003089 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003090 return 1;
3091 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003092 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01003093 return 1;
3094}
3095
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003096/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003097 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003098 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003099 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003100static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003101 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003102{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003103 struct sample tmp;
3104
Willy Tarreau7560dd42016-03-10 16:28:58 +01003105 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau9cfb71f2021-10-06 15:19:05 +02003106 if (!sample_conv_var2smp_sint(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003107 return 0;
3108
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003109 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003110 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003111 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003112 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003113 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3114 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003115 return 1;
3116 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003117 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003118 return 1;
3119 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003120 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01003121 return 1;
3122}
3123
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003124/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01003125 * result.
3126 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003127static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003128 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003129{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003130 if (smp->data.u.sint == LLONG_MIN)
3131 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003132 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003133 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01003134 return 1;
3135}
3136
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003137/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01003138 * false. The output is a BOOL.
3139 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003140static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003141 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003142{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003143 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003144 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003145 return 1;
3146}
3147
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003148/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01003149 * truee. The output is a BOOL.
3150 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003151static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003152 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003153{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003154 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003155 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003156 return 1;
3157}
3158
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003159/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01003160 * The output is a BOOL.
3161 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003162static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003163 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003164{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003165 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003166 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003167 return 1;
3168}
3169
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003170/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01003171 * The output is a BOOL.
3172 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003173static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003174 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003175{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003176 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003177 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003178 return 1;
3179}
3180
Willy Tarreau280f42b2018-02-19 15:34:12 +01003181/* appends an optional const string, an optional variable contents and another
3182 * optional const string to an existing string.
3183 */
3184static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
3185{
Willy Tarreau83061a82018-07-13 11:56:34 +02003186 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003187 struct sample tmp;
3188 int max;
3189
Willy Tarreau591fc3a2021-01-08 16:08:43 +01003190 trash = alloc_trash_chunk();
William Dauchye9970102021-01-11 11:05:58 +01003191 if (!trash)
3192 return 0;
3193
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003194 trash->data = smp->data.u.str.data;
3195 if (trash->data > trash->size - 1)
3196 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003197
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003198 memcpy(trash->area, smp->data.u.str.area, trash->data);
3199 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003200
3201 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003202 max = arg_p[0].data.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, arg_p[0].data.str.area, max);
3208 trash->data += max;
3209 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003210 }
3211
3212 /* append second string (variable) if it's found and we can turn it
3213 * into a string.
3214 */
3215 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3216 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3217 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3218 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3219
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003220 max = tmp.data.u.str.data;
3221 if (max > trash->size - 1 - trash->data)
3222 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003223
3224 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003225 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3226 max);
3227 trash->data += max;
3228 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003229 }
3230 }
3231
3232 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003233 max = arg_p[2].data.str.data;
3234 if (max > trash->size - 1 - trash->data)
3235 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003236
3237 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003238 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3239 trash->data += max;
3240 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003241 }
3242
3243 smp->data.u.str = *trash;
3244 smp->data.type = SMP_T_STR;
Willy Tarreau591fc3a2021-01-08 16:08:43 +01003245 smp_dup(smp);
3246 free_trash_chunk(trash);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003247 return 1;
3248}
3249
3250/* This function checks the "concat" converter's arguments and extracts the
3251 * variable name and its scope.
3252 */
3253static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3254 const char *file, int line, char **err)
3255{
3256 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003257 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3258 memprintf(err, "failed to register variable name '%s'",
3259 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003260 return 0;
3261 }
3262 return 1;
3263}
3264
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003265/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003266 * is compatible with strcmp(3)'s return value.
3267 */
3268static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3269{
3270 struct sample tmp;
3271 int max, result;
3272
3273 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3274 if (arg_p[0].type != ARGT_VAR)
3275 return 0;
Willy Tarreau8fdaf252021-10-06 15:30:52 +02003276
3277 if (!sample_conv_var2smp(&arg_p[0].data.var, &tmp, SMP_T_STR))
Tim Duesterhusca097c12018-04-27 21:18:45 +02003278 return 0;
3279
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003280 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3281 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003282 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003283 if (smp->data.u.str.data != tmp.data.u.str.data) {
3284 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003285 result = -1;
3286 }
3287 else {
3288 result = 1;
3289 }
3290 }
3291 }
3292
3293 smp->data.u.sint = result;
3294 smp->data.type = SMP_T_SINT;
3295 return 1;
3296}
3297
Willy Tarreau2a8a2f02021-05-09 11:59:49 +02003298#if defined(HAVE_CRYPTO_memcmp)
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003299/* Compares bytestring with a variable containing a bytestring. Return value
3300 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3301 *
3302 * Comparison will be performed in constant time if both bytestrings are of
3303 * the same length. If the lengths differ execution time will not be constant.
3304 */
3305static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3306{
3307 struct sample tmp;
3308 int result;
3309
3310 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3311 if (arg_p[0].type != ARGT_VAR)
3312 return 0;
Willy Tarreau8fdaf252021-10-06 15:30:52 +02003313
3314 if (!sample_conv_var2smp(&arg_p[0].data.var, &tmp, SMP_T_BIN))
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003315 return 0;
3316
3317 if (smp->data.u.str.data != tmp.data.u.str.data) {
3318 smp->data.u.sint = 0;
3319 smp->data.type = SMP_T_BOOL;
3320 return 1;
3321 }
3322
3323 /* The following comparison is performed in constant time. */
3324 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3325
3326 smp->data.u.sint = result == 0;
3327 smp->data.type = SMP_T_BOOL;
3328 return 1;
3329}
3330#endif
3331
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02003332/* Takes a boolean as input. Returns the first argument if that boolean is true and
3333 * the second argument otherwise.
3334 */
3335static int sample_conv_iif(const struct arg *arg_p, struct sample *smp, void *private)
3336{
3337 smp->data.type = SMP_T_STR;
3338 smp->flags |= SMP_F_CONST;
3339
3340 if (smp->data.u.sint) {
3341 smp->data.u.str.data = arg_p[0].data.str.data;
3342 smp->data.u.str.area = arg_p[0].data.str.area;
3343 }
3344 else {
3345 smp->data.u.str.data = arg_p[1].data.str.data;
3346 smp->data.u.str.area = arg_p[1].data.str.area;
3347 }
3348
3349 return 1;
3350}
3351
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003352#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3353#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3354#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3355
3356/*
3357 * Extract the field value of an input binary sample. Takes a mandatory argument:
3358 * the protocol buffers field identifier (dotted notation) internally represented
3359 * as an array of unsigned integers and its size.
3360 * Return 1 if the field was found, 0 if not.
3361 */
3362static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3363{
3364 unsigned char *pos;
3365 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003366
3367 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003368 grpc_left = smp->data.u.str.data;
3369
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003370 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003371 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003372
3373 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3374
3375 pos += GRPC_MSG_HEADER_SZ;
3376 grpc_left -= GRPC_MSG_HEADER_SZ;
3377
3378 if (grpc_left < left)
3379 return 0;
3380
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003381 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3382 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003383
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003384 grpc_left -= grpc_msg_len;
3385 }
3386
3387 return 0;
3388}
3389
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003390static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3391{
3392 unsigned char *pos;
3393 size_t left;
3394
3395 pos = (unsigned char *)smp->data.u.str.area;
3396 left = smp->data.u.str.data;
3397
3398 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3399}
3400
3401static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3402 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003403{
3404 if (!args[1].type) {
3405 args[1].type = ARGT_SINT;
3406 args[1].data.sint = PBUF_T_BINARY;
3407 }
3408 else {
3409 int pbuf_type;
3410
3411 pbuf_type = protobuf_type(args[1].data.str.area);
3412 if (pbuf_type == -1) {
3413 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3414 return 0;
3415 }
3416
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003417 chunk_destroy(&args[1].data.str);
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003418 args[1].type = ARGT_SINT;
3419 args[1].data.sint = pbuf_type;
3420 }
3421
3422 return 1;
3423}
3424
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003425/*
3426 * Extract the tag value of an input binary sample. Takes a mandatory argument:
3427 * the FIX protocol tag identifier.
3428 * Return 1 if the tag was found, 0 if not.
3429 */
3430static int sample_conv_fix_tag_value(const struct arg *arg_p, struct sample *smp, void *private)
3431{
3432 struct ist value;
3433
3434 smp->flags &= ~SMP_F_MAY_CHANGE;
3435 value = fix_tag_value(ist2(smp->data.u.str.area, smp->data.u.str.data),
3436 arg_p[0].data.sint);
3437 if (!istlen(value)) {
Christopher Faulet08da2732021-10-13 17:58:53 +02003438 if (isttest(value)) {
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003439 /* value != IST_NULL, need more data */
3440 smp->flags |= SMP_F_MAY_CHANGE;
3441 }
3442 return 0;
3443 }
3444
3445 smp->data.u.str = ist2buf(value);
3446 smp->flags |= SMP_F_CONST;
3447
3448 return 1;
3449}
3450
3451/* This function checks the "fix_tag_value" converter configuration.
3452 * It expects a "known" (by HAProxy) tag name or ID.
3453 * Tag string names are converted to their ID counterpart because this is the
3454 * format they are sent over the wire.
3455 */
3456static int sample_conv_fix_value_check(struct arg *args, struct sample_conv *conv,
3457 const char *file, int line, char **err)
3458{
3459 struct ist str;
3460 unsigned int tag;
3461
3462 str = ist2(args[0].data.str.area, args[0].data.str.data);
3463 tag = fix_tagid(str);
3464 if (!tag) {
3465 memprintf(err, "Unknown FIX tag name '%s'", args[0].data.str.area);
3466 return 0;
3467 }
3468
3469 chunk_destroy(&args[0].data.str);
3470 args[0].type = ARGT_SINT;
3471 args[0].data.sint = tag;
3472
3473 return 1;
3474}
3475
3476/*
3477 * Checks that a buffer contains a valid FIX message
3478 *
3479 * Return 1 if the check could be run, 0 if not.
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003480 * The result of the analyse itself is stored in <smp> as a boolean
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003481 */
3482static int sample_conv_fix_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3483{
3484 struct ist msg;
3485
3486 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3487
3488 smp->flags &= ~SMP_F_MAY_CHANGE;
3489 switch (fix_validate_message(msg)) {
3490 case FIX_VALID_MESSAGE:
3491 smp->data.type = SMP_T_BOOL;
3492 smp->data.u.sint = 1;
3493 return 1;
3494 case FIX_NEED_MORE_DATA:
3495 smp->flags |= SMP_F_MAY_CHANGE;
3496 return 0;
3497 case FIX_INVALID_MESSAGE:
3498 smp->data.type = SMP_T_BOOL;
3499 smp->data.u.sint = 0;
3500 return 1;
3501 }
3502 return 0;
3503}
3504
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003505/*
3506 * Extract the field value of an input binary sample containing an MQTT packet.
3507 * Takes 2 mandatory arguments:
3508 * - packet type
3509 * - field name
3510 *
3511 * return 1 if the field was found, 0 if not.
3512 */
3513static int sample_conv_mqtt_field_value(const struct arg *arg_p, struct sample *smp, void *private)
3514{
3515 struct ist pkt, value;
3516 int type, fieldname_id;
3517
3518 pkt = ist2(smp->data.u.str.area, smp->data.u.str.data);
3519 type = arg_p[0].data.sint;
3520 fieldname_id = arg_p[1].data.sint;
3521
3522 smp->flags &= ~SMP_F_MAY_CHANGE;
3523 value = mqtt_field_value(pkt, type, fieldname_id);
3524 if (!istlen(value)) {
3525 if (isttest(value)) {
3526 /* value != IST_NULL, need more data */
3527 smp->flags |= SMP_F_MAY_CHANGE;
3528 }
3529 return 0;
3530 }
3531
3532 smp->data.u.str = ist2buf(value);
3533 smp->flags |= SMP_F_CONST;
3534 return 1;
3535}
3536
3537/*
3538 * this function checks the "mqtt_field_value" converter configuration.
3539 * It expects a known packet type name or ID and a field name, in this order
3540 *
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003541 * Args[0] will be turned into a MQTT_CPT_* value for direct matching when parsing
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003542 * a packet.
3543 */
3544static int sample_conv_mqtt_field_value_check(struct arg *args, struct sample_conv *conv,
3545 const char *file, int line, char **err)
3546{
3547 int type, fieldname_id;
3548
3549 /* check the MQTT packet type is valid */
3550 type = mqtt_typeid(ist2(args[0].data.str.area, args[0].data.str.data));
3551 if (type == MQTT_CPT_INVALID) {
3552 memprintf(err, "Unknown MQTT type '%s'", args[0].data.str.area);
3553 return 0;
3554 }
3555
3556 /* check the field name belongs to the MQTT packet type */
3557 fieldname_id = mqtt_check_type_fieldname(type, ist2(args[1].data.str.area, args[1].data.str.data));
3558 if (fieldname_id == MQTT_FN_INVALID) {
3559 memprintf(err, "Unknown MQTT field name '%s' for packet type '%s'", args[1].data.str.area,
3560 args[0].data.str.area);
3561 return 0;
3562 }
3563
3564 /* save numeric counterparts of type and field name */
3565 chunk_destroy(&args[0].data.str);
3566 chunk_destroy(&args[1].data.str);
3567 args[0].type = ARGT_SINT;
3568 args[0].data.sint = type;
3569 args[1].type = ARGT_SINT;
3570 args[1].data.sint = fieldname_id;
3571
3572 return 1;
3573}
3574
3575/*
3576 * Checks that <smp> contains a valid MQTT message
3577 *
3578 * The function returns 1 if the check was run to its end, 0 otherwise.
3579 * The result of the analyse itself is stored in <smp> as a boolean.
3580 */
3581static int sample_conv_mqtt_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3582{
3583 struct ist msg;
3584
3585 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3586
3587 smp->flags &= ~SMP_F_MAY_CHANGE;
3588 switch (mqtt_validate_message(msg, NULL)) {
3589 case FIX_VALID_MESSAGE:
3590 smp->data.type = SMP_T_BOOL;
3591 smp->data.u.sint = 1;
3592 return 1;
3593 case FIX_NEED_MORE_DATA:
3594 smp->flags |= SMP_F_MAY_CHANGE;
3595 return 0;
3596 case FIX_INVALID_MESSAGE:
3597 smp->data.type = SMP_T_BOOL;
3598 smp->data.u.sint = 0;
3599 return 1;
3600 }
3601 return 0;
3602}
3603
Tim Duesterhusca097c12018-04-27 21:18:45 +02003604/* This function checks the "strcmp" converter's arguments and extracts the
3605 * variable name and its scope.
3606 */
3607static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3608 const char *file, int line, char **err)
3609{
Willy Tarreaua1169b62021-05-08 06:50:28 +02003610 if (!args[0].data.str.data) {
3611 memprintf(err, "missing variable name");
3612 return 0;
3613 }
3614
Tim Duesterhusca097c12018-04-27 21:18:45 +02003615 /* Try to decode a variable. */
3616 if (vars_check_arg(&args[0], NULL))
3617 return 1;
3618
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003619 memprintf(err, "failed to register variable name '%s'",
3620 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003621 return 0;
3622}
3623
Willy Tarreau2a8a2f02021-05-09 11:59:49 +02003624#if defined(HAVE_CRYPTO_memcmp)
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003625/* This function checks the "secure_memcmp" converter's arguments and extracts the
3626 * variable name and its scope.
3627 */
3628static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3629 const char *file, int line, char **err)
3630{
Willy Tarreaua1169b62021-05-08 06:50:28 +02003631 if (!args[0].data.str.data) {
3632 memprintf(err, "missing variable name");
3633 return 0;
3634 }
3635
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003636 /* Try to decode a variable. */
3637 if (vars_check_arg(&args[0], NULL))
3638 return 1;
3639
3640 memprintf(err, "failed to register variable name '%s'",
3641 args[0].data.str.area);
3642 return 0;
3643}
3644#endif
3645
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003646/**/
3647static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3648{
3649 struct buffer *tmp;
3650 uint32_t n;
3651
3652 n = htonl((uint32_t)smp->data.u.sint);
3653 tmp = get_trash_chunk();
3654
3655 memcpy(b_head(tmp), &n, 4);
3656 b_add(tmp, 4);
3657
3658 smp->data.u.str = *tmp;
3659 smp->data.type = SMP_T_BIN;
3660 return 1;
3661}
3662
Christopher Fauletea159d62020-04-01 16:21:44 +02003663/**/
3664static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3665{
3666 char *p;
3667 size_t l;
3668
3669 p = smp->data.u.str.area;
3670 for (l = 0; l < smp->data.u.str.data; l++) {
3671 if (*(p+l) == '\r' || *(p+l) == '\n')
3672 break;
3673 }
3674 smp->data.u.str.data = l;
3675 return 1;
3676}
3677
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003678/**/
3679static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3680{
3681 char *delimiters, *p;
3682 size_t dlen, l;
3683
3684 delimiters = arg_p[0].data.str.area;
3685 dlen = arg_p[0].data.str.data;
3686
3687 l = smp->data.u.str.data;
3688 p = smp->data.u.str.area;
3689 while (l && memchr(delimiters, *p, dlen) != NULL) {
3690 p++;
3691 l--;
3692 }
3693
3694 smp->data.u.str.area = p;
3695 smp->data.u.str.data = l;
3696 return 1;
3697}
3698
Christopher Faulet568415a2020-04-01 17:24:47 +02003699/**/
3700static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3701{
3702 char *delimiters, *p;
3703 size_t dlen, l;
3704
3705 delimiters = arg_p[0].data.str.area;
3706 dlen = arg_p[0].data.str.data;
3707
3708 l = smp->data.u.str.data;
3709 p = smp->data.u.str.area + l - 1;
3710 while (l && memchr(delimiters, *p, dlen) != NULL) {
3711 p--;
3712 l--;
3713 }
3714
3715 smp->data.u.str.data = l;
3716 return 1;
3717}
3718
Alex51c8ad42021-04-15 16:45:15 +02003719/* This function checks the "json_query" converter's arguments. */
3720static int sample_check_json_query(struct arg *arg, struct sample_conv *conv,
3721 const char *file, int line, char **err)
3722{
3723 if (arg[0].data.str.data == 0) {
3724 memprintf(err, "json_path must not be empty");
3725 return 0;
3726 }
3727
3728 if (arg[1].data.str.data != 0) {
3729 if (strcmp(arg[1].data.str.area, "int") != 0) {
3730 memprintf(err, "output_type only supports \"int\" as argument");
3731 return 0;
3732 } else {
3733 arg[1].type = ARGT_SINT;
3734 arg[1].data.sint = 0;
3735 }
3736 }
3737 return 1;
3738}
3739
3740/* Limit JSON integer values to the range [-(2**53)+1, (2**53)-1] as per
3741 * the recommendation for interoperable integers in section 6 of RFC 7159.
3742 */
3743#define JSON_INT_MAX ((1LL << 53) - 1)
3744#define JSON_INT_MIN (-JSON_INT_MAX)
3745
3746/* This sample function get the value from a given json string.
3747 * The mjson library is used to parse the JSON struct
3748 */
3749static int sample_conv_json_query(const struct arg *args, struct sample *smp, void *private)
3750{
3751 struct buffer *trash = get_trash_chunk();
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003752 const char *token; /* holds the temporary string from mjson_find */
3753 int token_size; /* holds the length of <token> */
Alex51c8ad42021-04-15 16:45:15 +02003754
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003755 enum mjson_tok token_type;
Alex51c8ad42021-04-15 16:45:15 +02003756
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003757 token_type = mjson_find(smp->data.u.str.area, smp->data.u.str.data, args[0].data.str.area, &token, &token_size);
3758
3759 switch (token_type) {
Alex51c8ad42021-04-15 16:45:15 +02003760 case MJSON_TOK_NUMBER:
3761 if (args[1].type == ARGT_SINT) {
Willy Tarreaufb601952021-05-14 08:51:53 +02003762 smp->data.u.sint = strtoll(token, NULL, 0);
Alex51c8ad42021-04-15 16:45:15 +02003763
3764 if (smp->data.u.sint < JSON_INT_MIN || smp->data.u.sint > JSON_INT_MAX)
3765 return 0;
3766
3767 smp->data.type = SMP_T_SINT;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003768
3769 return 1;
Alex51c8ad42021-04-15 16:45:15 +02003770 } else {
3771 double double_val;
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003772
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003773 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 +02003774 return 0;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003775
3776 trash->data = snprintf(trash->area,trash->size,"%g",double_val);
3777 smp->data.u.str = *trash;
3778 smp->data.type = SMP_T_STR;
3779
3780 return 1;
Alex51c8ad42021-04-15 16:45:15 +02003781 }
Alex51c8ad42021-04-15 16:45:15 +02003782 case MJSON_TOK_TRUE:
3783 smp->data.type = SMP_T_BOOL;
3784 smp->data.u.sint = 1;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003785
3786 return 1;
Alex51c8ad42021-04-15 16:45:15 +02003787 case MJSON_TOK_FALSE:
3788 smp->data.type = SMP_T_BOOL;
3789 smp->data.u.sint = 0;
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003790
3791 return 1;
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003792 case MJSON_TOK_STRING: {
3793 int len;
3794
3795 len = mjson_get_string(smp->data.u.str.area, smp->data.u.str.data, args[0].data.str.area, trash->area, trash->size);
3796
3797 if (len == -1) {
Alex51c8ad42021-04-15 16:45:15 +02003798 /* invalid string */
3799 return 0;
Alex51c8ad42021-04-15 16:45:15 +02003800 }
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003801
3802 trash->data = len;
3803 smp->data.u.str = *trash;
3804 smp->data.type = SMP_T_STR;
3805
3806 return 1;
Tim Duesterhus4809c8c2021-04-15 18:08:48 +02003807 }
Tim Duesterhus8f3bc8f2021-04-15 18:14:32 +02003808 case MJSON_TOK_NULL:
3809 case MJSON_TOK_ARRAY:
3810 case MJSON_TOK_OBJECT:
3811 /* We cannot handle these. */
3812 return 0;
3813 case MJSON_TOK_INVALID:
3814 /* Nothing matches the query. */
3815 return 0;
3816 case MJSON_TOK_KEY:
3817 /* This is not a valid return value according to the
3818 * mjson documentation, but we handle it to benefit
3819 * from '-Wswitch'.
3820 */
Alex51c8ad42021-04-15 16:45:15 +02003821 return 0;
3822 }
Tim Duesterhus3b9cdf12021-04-15 18:40:06 +02003823
3824 my_unreachable();
3825 return 0;
Alex51c8ad42021-04-15 16:45:15 +02003826}
3827
3828
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003829/************************************************************************/
3830/* All supported sample fetch functions must be declared here */
3831/************************************************************************/
3832
3833/* force TRUE to be returned at the fetch level */
3834static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003835smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003836{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003837 if (!smp_make_rw(smp))
3838 return 0;
3839
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003840 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003841 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003842 return 1;
3843}
3844
3845/* force FALSE to be returned at the fetch level */
3846static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003847smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003848{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003849 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003850 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003851 return 1;
3852}
3853
3854/* retrieve environment variable $1 as a string */
3855static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003856smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003857{
3858 char *env;
3859
Christopher Faulete6e7a582021-01-29 11:29:28 +01003860 if (args[0].type != ARGT_STR)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003861 return 0;
3862
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003863 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003864 if (!env)
3865 return 0;
3866
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003867 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003868 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003869 smp->data.u.str.area = env;
3870 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003871 return 1;
3872}
3873
Damien Claisseae6f1252019-10-30 15:57:28 +00003874/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3875 * optional string representing the unit of the result: "s" for seconds, "ms" for
3876 * milliseconds and "us" for microseconds.
3877 * Returns 0 on error and non-zero if OK.
3878 */
3879int smp_check_date_unit(struct arg *args, char **err)
3880{
3881 if (args[1].type == ARGT_STR) {
Christopher Faulet95917132020-08-05 23:07:07 +02003882 long long int unit;
3883
Damien Claisseae6f1252019-10-30 15:57:28 +00003884 if (strcmp(args[1].data.str.area, "s") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003885 unit = TIME_UNIT_S;
Damien Claisseae6f1252019-10-30 15:57:28 +00003886 }
3887 else if (strcmp(args[1].data.str.area, "ms") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003888 unit = TIME_UNIT_MS;
Damien Claisseae6f1252019-10-30 15:57:28 +00003889 }
3890 else if (strcmp(args[1].data.str.area, "us") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003891 unit = TIME_UNIT_US;
Damien Claisseae6f1252019-10-30 15:57:28 +00003892 }
3893 else {
3894 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3895 args[1].data.str.area);
3896 return 0;
3897 }
Christopher Faulet95917132020-08-05 23:07:07 +02003898
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003899 chunk_destroy(&args[1].data.str);
Damien Claisseae6f1252019-10-30 15:57:28 +00003900 args[1].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02003901 args[1].data.sint = unit;
Damien Claisseae6f1252019-10-30 15:57:28 +00003902 }
3903 else if (args[1].type != ARGT_STOP) {
3904 memprintf(err, "Unexpected arg type");
3905 return 0;
3906 }
3907
3908 return 1;
3909}
3910
3911/* retrieve the current local date in epoch time, converts it to milliseconds
3912 * or microseconds if asked to in optional args[1] unit param, and applies an
3913 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003914 */
3915static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003916smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003917{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003918 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003919
Damien Claisseae6f1252019-10-30 15:57:28 +00003920 /* report in milliseconds */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003921 if (args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
Damien Claisseae6f1252019-10-30 15:57:28 +00003922 smp->data.u.sint *= 1000;
3923 smp->data.u.sint += date.tv_usec / 1000;
3924 }
3925 /* report in microseconds */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003926 else if (args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
Damien Claisseae6f1252019-10-30 15:57:28 +00003927 smp->data.u.sint *= 1000000;
3928 smp->data.u.sint += date.tv_usec;
3929 }
3930
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003931 /* add offset */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003932 if (args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003933 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003934
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003935 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003936 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3937 return 1;
3938}
3939
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003940/* retrieve the current microsecond part of the date */
3941static int
3942smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3943{
3944 smp->data.u.sint = date.tv_usec;
3945 smp->data.type = SMP_T_SINT;
3946 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3947 return 1;
3948}
3949
3950
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003951/* returns the hostname */
3952static int
3953smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3954{
3955 smp->data.type = SMP_T_STR;
3956 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003957 smp->data.u.str.area = hostname;
3958 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003959 return 1;
3960}
3961
Willy Tarreau0f30d262014-11-24 16:02:05 +01003962/* returns the number of processes */
3963static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003964smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003965{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003966 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003967 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003968 return 1;
3969}
3970
3971/* returns the number of the current process (between 1 and nbproc */
3972static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003973smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003974{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003975 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003976 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003977 return 1;
3978}
3979
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003980/* returns the number of the current thread (between 1 and nbthread */
3981static int
3982smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3983{
3984 smp->data.type = SMP_T_SINT;
3985 smp->data.u.sint = tid;
3986 return 1;
3987}
3988
Willy Tarreau84310e22014-02-14 11:59:04 +01003989/* generate a random 32-bit integer for whatever purpose, with an optional
3990 * range specified in argument.
3991 */
3992static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003993smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003994{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003995 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003996
3997 /* reduce if needed. Don't do a modulo, use all bits! */
Christopher Faulete6e7a582021-01-29 11:29:28 +01003998 if (args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003999 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01004000
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004001 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01004002 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
4003 return 1;
4004}
4005
Willy Tarreau0f30d262014-11-24 16:02:05 +01004006/* returns true if the current process is stopping */
4007static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02004008smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01004009{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004010 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004011 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01004012 return 1;
4013}
4014
Willy Tarreau70fe9442018-11-22 16:07:39 +01004015/* returns the number of calls of the current stream's process_stream() */
4016static int
4017smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
4018{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004019 if (!smp->strm)
4020 return 0;
4021
Willy Tarreau70fe9442018-11-22 16:07:39 +01004022 smp->data.type = SMP_T_SINT;
4023 smp->data.u.sint = smp->strm->task->calls;
4024 return 1;
4025}
4026
4027/* returns the average number of nanoseconds spent processing the stream per call */
4028static int
4029smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
4030{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004031 if (!smp->strm)
4032 return 0;
4033
Willy Tarreau70fe9442018-11-22 16:07:39 +01004034 smp->data.type = SMP_T_SINT;
4035 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
4036 return 1;
4037}
4038
4039/* returns the total number of nanoseconds spent processing the stream */
4040static int
4041smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
4042{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004043 if (!smp->strm)
4044 return 0;
4045
Willy Tarreau70fe9442018-11-22 16:07:39 +01004046 smp->data.type = SMP_T_SINT;
4047 smp->data.u.sint = smp->strm->task->cpu_time;
4048 return 1;
4049}
4050
4051/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
4052static int
4053smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
4054{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004055 if (!smp->strm)
4056 return 0;
4057
Willy Tarreau70fe9442018-11-22 16:07:39 +01004058 smp->data.type = SMP_T_SINT;
4059 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
4060 return 1;
4061}
4062
4063/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
4064static int
4065smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
4066{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02004067 if (!smp->strm)
4068 return 0;
4069
Willy Tarreau70fe9442018-11-22 16:07:39 +01004070 smp->data.type = SMP_T_SINT;
4071 smp->data.u.sint = smp->strm->task->lat_time;
4072 return 1;
4073}
4074
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004075static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
4076{
4077 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004078 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004079 smp->data.u.str.area = args[0].data.str.area;
4080 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004081 return 1;
4082}
4083
4084static int smp_check_const_bool(struct arg *args, char **err)
4085{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004086 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
4087 strcasecmp(args[0].data.str.area, "1") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004088 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004089 args[0].type = ARGT_SINT;
4090 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004091 return 1;
4092 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004093 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
4094 strcasecmp(args[0].data.str.area, "0") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004095 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004096 args[0].type = ARGT_SINT;
4097 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004098 return 1;
4099 }
4100 memprintf(err, "Expects 'true', 'false', '0' or '1'");
4101 return 0;
4102}
4103
4104static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
4105{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004106 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004107 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004108 return 1;
4109}
4110
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02004111static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004112{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004113 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004114 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004115 return 1;
4116}
4117
4118static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
4119{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004120 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004121 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004122 return 1;
4123}
4124
4125static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
4126{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004127 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004128 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004129 return 1;
4130}
4131
4132static int smp_check_const_bin(struct arg *args, char **err)
4133{
David Carlier64a16ab2016-04-08 10:37:02 +01004134 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004135 int binstrlen;
4136
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004137 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004138 return 0;
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004139 chunk_destroy(&args[0].data.str);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004140 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004141 args[0].data.str.area = binstr;
4142 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004143 return 1;
4144}
4145
4146static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
4147{
4148 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004149 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004150 smp->data.u.str.area = args[0].data.str.area;
4151 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004152 return 1;
4153}
4154
4155static int smp_check_const_meth(struct arg *args, char **err)
4156{
4157 enum http_meth_t meth;
4158 int i;
4159
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004160 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004161 if (meth != HTTP_METH_OTHER) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02004162 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004163 args[0].type = ARGT_SINT;
4164 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004165 } else {
Ilya Shipitsin6b79f382020-07-23 00:32:55 +05004166 /* Check method avalaibility. A method is a token defined as :
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004167 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
4168 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
4169 * token = 1*tchar
4170 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004171 for (i = 0; i < args[0].data.str.data; i++) {
4172 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004173 memprintf(err, "expects valid method.");
4174 return 0;
4175 }
4176 }
4177 }
4178 return 1;
4179}
4180
4181static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
4182{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02004183 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02004184 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004185 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004186 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004187 smp->data.u.meth.str.area = "";
4188 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004189 } else {
4190 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02004191 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004192 smp->data.u.meth.str.area = args[0].data.str.area;
4193 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004194 }
4195 return 1;
4196}
4197
Luca Schimweg8a694b82019-09-10 15:42:52 +02004198// This function checks the "uuid" sample's arguments.
4199// Function won't get called when no parameter is specified (maybe a bug?)
4200static int smp_check_uuid(struct arg *args, char **err)
4201{
4202 if (!args[0].type) {
4203 args[0].type = ARGT_SINT;
4204 args[0].data.sint = 4;
4205 }
4206 else if (args[0].data.sint != 4) {
4207 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
4208 return 0;
4209 }
4210
4211 return 1;
4212}
4213
4214// Generate a RFC4122 UUID (default is v4 = fully random)
4215static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
4216{
4217 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01004218 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02004219 smp->data.type = SMP_T_STR;
4220 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
4221 smp->data.u.str = trash;
4222 return 1;
4223 }
4224
4225 // more implementations of other uuid formats possible here
4226 return 0;
4227}
4228
Willy Tarreau5b8ad222013-07-25 12:17:57 +02004229/* Note: must not be declared <const> as its list will be overwritten.
4230 * Note: fetches that may return multiple types must be declared as the lowest
4231 * common denominator, the type that can be casted into all other ones. For
4232 * instance IPv4/IPv6 must be declared IPv4.
4233 */
4234static struct sample_fetch_kw_list smp_kws = {ILH, {
Willy Tarreau0209c972021-03-26 12:03:11 +01004235 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_CONST },
4236 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_CONST },
4237 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_CONST },
4238 { "date", smp_fetch_date, ARG2(0,SINT,STR), smp_check_date_unit, SMP_T_SINT, SMP_USE_CONST },
4239 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_CONST },
4240 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_CONST },
4241 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_CONST },
4242 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_CONST },
4243 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_CONST },
4244 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_CONST },
Willy Tarreau0f30d262014-11-24 16:02:05 +01004245 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau0209c972021-03-26 12:03:11 +01004246 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_CONST },
Willy Tarreau70fe9442018-11-22 16:07:39 +01004247
4248 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4249 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4250 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4251 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
4252 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02004253
Willy Tarreau0209c972021-03-26 12:03:11 +01004254 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_CONST },
4255 { "bool", smp_fetch_const_bool, ARG1(1,STR), smp_check_const_bool, SMP_T_BOOL, SMP_USE_CONST },
4256 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_CONST },
4257 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_CONST },
4258 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_CONST },
4259 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_CONST },
4260 { "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 +02004261
Willy Tarreau5b8ad222013-07-25 12:17:57 +02004262 { /* END */ },
4263}};
4264
Willy Tarreau0108d902018-11-25 19:14:37 +01004265INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
4266
Emeric Brun107ca302010-01-04 16:16:05 +01004267/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02004268static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Moemen MHEDHBI848216f2021-04-02 01:05:07 +02004269 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
4270 { "b64dec", sample_conv_base642bin, 0, NULL, SMP_T_STR, SMP_T_BIN },
4271 { "base64", sample_conv_bin2base64, 0, NULL, SMP_T_BIN, SMP_T_STR },
4272 { "ub64enc", sample_conv_bin2base64url,0, NULL, SMP_T_BIN, SMP_T_STR },
4273 { "ub64dec", sample_conv_base64url2bin,0, NULL, SMP_T_STR, SMP_T_BIN },
4274 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
4275 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
4276 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
4277 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
4278 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
4279 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
4280 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
4281 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
4282 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4283 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4284 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4285 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4286 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4287 { "xxh3", sample_conv_xxh3, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4288 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4289 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
4290 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
4291 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
4292 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
4293 { "word", sample_conv_word, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
4294 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
4295 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02004296#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01004297 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Ilya Shipitsin2c481d02021-03-26 23:35:31 +05004298#ifdef EVP_CIPH_GCM_MODE
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02004299 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
4300#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02004301 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
4302 { "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 +02004303#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01004304 { "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 +02004305 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Willy Tarreau2a8a2f02021-05-09 11:59:49 +02004306#if defined(HAVE_CRYPTO_memcmp)
Tim Duesterhusf38175c2020-06-09 11:48:42 +02004307 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
4308#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01004309
4310 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01004311 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
4312 { "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 +01004313
Baptiste Assmanne138dda2020-10-22 15:39:03 +02004314 /* FIX converters */
4315 { "fix_is_valid", sample_conv_fix_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4316 { "fix_tag_value", sample_conv_fix_tag_value, ARG1(1,STR), sample_conv_fix_value_check, SMP_T_BIN, SMP_T_BIN },
4317
Baptiste Assmanne279ca62020-10-27 18:10:06 +01004318 /* MQTT converters */
4319 { "mqtt_is_valid", sample_conv_mqtt_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4320 { "mqtt_field_value", sample_conv_mqtt_field_value, ARG2(2,STR,STR), sample_conv_mqtt_field_value_check, SMP_T_BIN, SMP_T_STR },
4321
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02004322 { "iif", sample_conv_iif, ARG2(2, STR, STR), NULL, SMP_T_BOOL, SMP_T_STR },
4323
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02004324 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4325 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4326 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4327 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
4328 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4329 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4330 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4331 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4332 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4333 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4334 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4335 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4336 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4337 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01004338
Christopher Fauletea159d62020-04-01 16:21:44 +02004339 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
4340 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02004341 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02004342 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Alex51c8ad42021-04-15 16:45:15 +02004343 { "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 +02004344 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01004345}};
4346
Willy Tarreau0108d902018-11-25 19:14:37 +01004347INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);