blob: 370ad1e8058c1c0c384e52c149222ed147ace88d [file] [log] [blame]
Emeric Brun107ca302010-01-04 16:16:05 +01001/*
Willy Tarreaucd3b0942012-04-27 21:52:18 +02002 * Sample management functions.
Emeric Brun107ca302010-01-04 16:16:05 +01003 *
4 * Copyright 2009-2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
Willy Tarreaucd3b0942012-04-27 21:52:18 +02005 * Copyright (C) 2012 Willy Tarreau <w@1wt.eu>
Emeric Brun107ca302010-01-04 16:16:05 +01006 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
Thierry FOURNIER317e1c42014-08-12 10:20:47 +020014#include <ctype.h>
Emeric Brun107ca302010-01-04 16:16:05 +010015#include <string.h>
16#include <arpa/inet.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020017#include <stdio.h>
Emeric Brun107ca302010-01-04 16:16:05 +010018
Willy Tarreaub2551052020-06-09 09:07:15 +020019#include <import/sha1.h>
20#include <import/xxhash.h>
Willy Tarreau7e2c6472012-10-29 20:44:36 +010021
Willy Tarreaub2551052020-06-09 09:07:15 +020022#include <haproxy/api.h>
23#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020024#include <haproxy/auth.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020025#include <haproxy/base64.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020026#include <haproxy/buf.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020027#include <haproxy/chunk.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020028#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020029#include <haproxy/global.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020030#include <haproxy/hash.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020031#include <haproxy/http.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020032#include <haproxy/net_helper.h>
Willy Tarreaub23e5952020-06-04 16:06:59 +020033#include <haproxy/protobuf.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020034#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020035#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020036#include <haproxy/sample.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/sink.h>
38#include <haproxy/stick_table.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020039#include <haproxy/tools.h>
Willy Tarreau8c42b8a2020-06-04 19:27:34 +020040#include <haproxy/uri_auth-t.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020041#include <haproxy/vars.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010042
Willy Tarreau1cf8f082014-02-07 12:14:54 +010043/* sample type names */
44const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020045 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010046 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010047 [SMP_T_SINT] = "sint",
48 [SMP_T_ADDR] = "addr",
49 [SMP_T_IPV4] = "ipv4",
50 [SMP_T_IPV6] = "ipv6",
51 [SMP_T_STR] = "str",
52 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020053 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010054};
55
Willy Tarreau12785782012-04-27 21:37:17 +020056/* static sample used in sample_process() when <p> is NULL */
Emeric Brune5c918b2017-06-14 14:15:36 +020057static THREAD_LOCAL struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010058
Willy Tarreau12785782012-04-27 21:37:17 +020059/* list head of all known sample fetch keywords */
60static struct sample_fetch_kw_list sample_fetches = {
61 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010062};
63
Willy Tarreau12785782012-04-27 21:37:17 +020064/* list head of all known sample format conversion keywords */
65static struct sample_conv_kw_list sample_convs = {
66 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010067};
68
Willy Tarreau80aca902013-01-07 15:42:20 +010069const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
70 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
71 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
72 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
73 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
74 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
75 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010076 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +010077
78 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
79 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
80 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
81 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
82 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
83 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010084 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010085
86 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
87 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
88 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
89 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
90 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
91 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010092 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010093
94 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
95 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
96 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
97 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
98 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
99 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100100 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100101
102 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
103 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
104 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
105 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
106 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
107 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100108 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100109
110 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
111 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
112 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
113 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
114 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
115 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100116 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100117
118 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
119 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
120 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
121 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
122 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
123 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100124 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100125
126 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
127 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
128 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
129 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
130 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
131 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100132 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100133
134 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
135 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
136 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
137 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
138 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
139 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100140 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100141
142 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
143 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
144 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
145 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
146 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
147 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100148 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100149
150 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
151 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
152 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
153 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
154 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
155 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100156 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100157
158 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
159 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
160 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
161 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
162 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
163 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100164 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100165
166 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
167 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
168 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
169 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
170 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
171 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100172 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100173
174 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
175 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
176 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
177 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
178 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
179 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100180 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100181
182 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
183 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
184 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
185 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
186 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
187 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200188 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100189
190 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
191 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
192 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
193 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
194 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
195 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200196 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100197
198 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
199 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
200 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
201 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
202 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
203 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200204 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100205
206 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
207 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
208 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
209 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
210 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
211 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200212 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100213
214 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
215 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
216 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
217 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
218 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100220 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100221
222 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
223 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
224 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
225 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
226 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
227 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100228 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100229
230 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
231 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
232 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
233 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
234 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
235 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100236 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100237
238 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
239 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
240 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
241 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
242 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
243 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100244 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100245};
246
247static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
248 [SMP_SRC_INTRN] = "internal state",
249 [SMP_SRC_LISTN] = "listener",
250 [SMP_SRC_FTEND] = "frontend",
251 [SMP_SRC_L4CLI] = "client address",
252 [SMP_SRC_L5CLI] = "client-side connection",
253 [SMP_SRC_TRACK] = "track counters",
254 [SMP_SRC_L6REQ] = "request buffer",
255 [SMP_SRC_HRQHV] = "HTTP request headers",
256 [SMP_SRC_HRQHP] = "HTTP request",
257 [SMP_SRC_HRQBO] = "HTTP request body",
258 [SMP_SRC_BKEND] = "backend",
259 [SMP_SRC_SERVR] = "server",
260 [SMP_SRC_L4SRV] = "server address",
261 [SMP_SRC_L5SRV] = "server-side connection",
262 [SMP_SRC_L6RES] = "response buffer",
263 [SMP_SRC_HRSHV] = "HTTP response headers",
264 [SMP_SRC_HRSHP] = "HTTP response",
265 [SMP_SRC_HRSBO] = "HTTP response body",
266 [SMP_SRC_RQFIN] = "request buffer statistics",
267 [SMP_SRC_RSFIN] = "response buffer statistics",
268 [SMP_SRC_TXFIN] = "transaction statistics",
269 [SMP_SRC_SSFIN] = "session statistics",
270};
271
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100272static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
273 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
274 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
275 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
276 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
277 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
278 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
279 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
280 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
281 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
282 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
283 [SMP_CKP_BE_SRV_CON] = "server source selection",
284 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
285 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
286 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
287 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
288 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
289 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
290 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
291 [SMP_CKP_FE_LOG_END] = "logs",
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100292 [SMP_CKP_BE_CHK_RUL] = "backend tcp-check rule",
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100293};
294
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100295/* This function returns the type of the data returned by the sample_expr.
296 * It assumes that the <expr> and all of its converters are properly
297 * initialized.
298 */
299inline
300int smp_expr_output_type(struct sample_expr *expr)
301{
302 struct sample_conv_expr *smp_expr;
303
304 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
305 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
306 return smp_expr->conv->out_type;
307 }
308 return expr->fetch->out_type;
309}
310
311
Willy Tarreau80aca902013-01-07 15:42:20 +0100312/* fill the trash with a comma-delimited list of source names for the <use> bit
313 * field which must be composed of a non-null set of SMP_USE_* flags. The return
314 * value is the pointer to the string in the trash buffer.
315 */
316const char *sample_src_names(unsigned int use)
317{
318 int bit;
319
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200320 trash.data = 0;
321 trash.area[0] = '\0';
Willy Tarreau80aca902013-01-07 15:42:20 +0100322 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
323 if (!(use & ~((1 << bit) - 1)))
324 break; /* no more bits */
325
326 if (!(use & (1 << bit)))
327 continue; /* bit not set */
328
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200329 trash.data += snprintf(trash.area + trash.data,
330 trash.size - trash.data, "%s%s",
331 (use & ((1 << bit) - 1)) ? "," : "",
332 fetch_src_names[bit]);
Willy Tarreau80aca902013-01-07 15:42:20 +0100333 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200334 return trash.area;
Willy Tarreau80aca902013-01-07 15:42:20 +0100335}
336
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100337/* return a pointer to the correct sample checkpoint name, or "unknown" when
338 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
339 * if set.
340 */
341const char *sample_ckp_names(unsigned int use)
342{
343 int bit;
344
345 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
346 if (use & (1 << bit))
347 return fetch_ckp_names[bit];
348 return "unknown sample check place, please report this bug";
349}
350
Emeric Brun107ca302010-01-04 16:16:05 +0100351/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100352 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
353 * for next parsing sessions. The fetch keywords capabilities are also computed
354 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100355 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100356void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100357{
Willy Tarreau80aca902013-01-07 15:42:20 +0100358 struct sample_fetch *sf;
359 int bit;
360
361 for (sf = kwl->kw; sf->kw != NULL; sf++) {
362 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
363 if (sf->use & (1 << bit))
364 sf->val |= fetch_cap[bit];
365 }
366 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100367}
368
369/*
Willy Tarreau12785782012-04-27 21:37:17 +0200370 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100371 * parsing sessions.
372 */
Willy Tarreau12785782012-04-27 21:37:17 +0200373void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100374{
Willy Tarreau12785782012-04-27 21:37:17 +0200375 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100376}
377
378/*
Willy Tarreau12785782012-04-27 21:37:17 +0200379 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100380 * string of <len> in buffer <kw>.
381 *
382 */
Willy Tarreau12785782012-04-27 21:37:17 +0200383struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100384{
385 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200386 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100387
Willy Tarreau12785782012-04-27 21:37:17 +0200388 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100389 for (index = 0; kwl->kw[index].kw != NULL; index++) {
390 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
391 kwl->kw[index].kw[len] == '\0')
392 return &kwl->kw[index];
393 }
394 }
395 return NULL;
396}
397
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100398/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100399 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100400 * <idx> is the index of the next sample fetch entry. It is used as private
401 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100402 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100403 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100404 * the list is reached.
405 */
406struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
407{
408 struct sample_fetch_kw_list *kwl;
409 struct sample_fetch *base;
410
411 if (!current) {
412 /* Get first kwl entry. */
413 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
414 (*idx) = 0;
415 } else {
416 /* Get kwl corresponding to the curret entry. */
417 base = current + 1 - (*idx);
418 kwl = container_of(base, struct sample_fetch_kw_list, kw);
419 }
420
421 while (1) {
422
423 /* Check if kwl is the last entry. */
424 if (&kwl->list == &sample_fetches.list)
425 return NULL;
426
427 /* idx contain the next keyword. If it is available, return it. */
428 if (kwl->kw[*idx].kw) {
429 (*idx)++;
430 return &kwl->kw[(*idx)-1];
431 }
432
433 /* get next entry in the main list, and return NULL if the end is reached. */
434 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
435
436 /* Set index to 0, ans do one other loop. */
437 (*idx) = 0;
438 }
439}
440
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100441/* This function browses the list of available converters. <current> is
442 * the last used converter. If it is the first call, it must set to NULL.
443 * <idx> is the index of the next converter entry. It is used as private
444 * value. It is useless to initiate it.
445 *
446 * It returns always the next sample_conv entry, and NULL when the end of
447 * the list is reached.
448 */
449struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
450{
451 struct sample_conv_kw_list *kwl;
452 struct sample_conv *base;
453
454 if (!current) {
455 /* Get first kwl entry. */
456 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
457 (*idx) = 0;
458 } else {
459 /* Get kwl corresponding to the curret entry. */
460 base = current + 1 - (*idx);
461 kwl = container_of(base, struct sample_conv_kw_list, kw);
462 }
463
464 while (1) {
465 /* Check if kwl is the last entry. */
466 if (&kwl->list == &sample_convs.list)
467 return NULL;
468
469 /* idx contain the next keyword. If it is available, return it. */
470 if (kwl->kw[*idx].kw) {
471 (*idx)++;
472 return &kwl->kw[(*idx)-1];
473 }
474
475 /* get next entry in the main list, and return NULL if the end is reached. */
476 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
477
478 /* Set index to 0, ans do one other loop. */
479 (*idx) = 0;
480 }
481}
482
Emeric Brun107ca302010-01-04 16:16:05 +0100483/*
Willy Tarreau12785782012-04-27 21:37:17 +0200484 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100485 * string of <len> in buffer <kw>.
486 *
487 */
Willy Tarreau12785782012-04-27 21:37:17 +0200488struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100489{
490 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200491 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100492
Willy Tarreau12785782012-04-27 21:37:17 +0200493 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100494 for (index = 0; kwl->kw[index].kw != NULL; index++) {
495 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
496 kwl->kw[index].kw[len] == '\0')
497 return &kwl->kw[index];
498 }
499 }
500 return NULL;
501}
502
Emeric Brun107ca302010-01-04 16:16:05 +0100503/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200504/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100505/******************************************************************/
506
Willy Tarreau342acb42012-04-23 22:03:39 +0200507static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100508{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200509 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200510 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100511 return 1;
512}
513
Willy Tarreau342acb42012-04-23 22:03:39 +0200514static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100515{
Willy Tarreau83061a82018-07-13 11:56:34 +0200516 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100517
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200518 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100519 return 0;
520
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200521 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200522 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200523 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100524 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100525
526 return 1;
527}
528
Willy Tarreau342acb42012-04-23 22:03:39 +0200529static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100530{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200531 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200532 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100533 return 1;
534}
535
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200536static int c_ipv62ip(struct sample *smp)
537{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200538 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200539 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100540 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200541 return 1;
542}
543
Willy Tarreau342acb42012-04-23 22:03:39 +0200544static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100545{
Willy Tarreau83061a82018-07-13 11:56:34 +0200546 struct buffer *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100547
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200548 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100549 return 0;
550
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200551 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200552 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200553 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100554 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100555 return 1;
556}
557
558/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200559static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100560{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200561 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100562}
563*/
564
Willy Tarreau342acb42012-04-23 22:03:39 +0200565static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100566{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200567 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200568 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100569 return 1;
570}
571
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200572static int c_int2ipv6(struct sample *smp)
573{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200574 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
575 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200576 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200577 return 1;
578}
579
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100580static int c_str2addr(struct sample *smp)
581{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200582 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4)) {
583 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100584 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200585 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100586 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100587 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100588 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200589 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100590 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100591 return 1;
592}
593
Willy Tarreau342acb42012-04-23 22:03:39 +0200594static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100595{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200596 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100597 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200598 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100599 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100600 return 1;
601}
602
Willy Tarreau342acb42012-04-23 22:03:39 +0200603static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100604{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200605 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100606 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200607 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100608 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100609 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100610}
611
Emeric Brun4b9e8022014-11-03 18:17:10 +0100612/*
613 * The NULL char always enforces the end of string if it is met.
614 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100615 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200616static int c_bin2str(struct sample *smp)
617{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100618 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200619
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200620 for (i = 0; i < smp->data.u.str.data; i++) {
621 if (!smp->data.u.str.area[i]) {
622 smp->data.u.str.data = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100623 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100624 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200625 }
Christopher Faulet472ad512020-04-30 09:57:40 +0200626 smp->data.type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200627 return 1;
628}
629
Willy Tarreau342acb42012-04-23 22:03:39 +0200630static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100631{
Willy Tarreau83061a82018-07-13 11:56:34 +0200632 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100633 char *pos;
634
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200635 pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100636 if (!pos)
637 return 0;
638
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200639 trash->size = trash->size - (pos - trash->area);
640 trash->area = pos;
641 trash->data = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200642 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200643 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100644 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100645 return 1;
646}
647
Joseph Herlant757f5ad2018-11-15 12:14:56 -0800648/* This function unconditionally duplicates data and removes the "const" flag.
Willy Tarreauad635822016-08-08 19:21:09 +0200649 * For strings and binary blocks, it also provides a known allocated size with
650 * a length that is capped to the size, and ensures a trailing zero is always
651 * appended for strings. This is necessary for some operations which may
652 * require to extend the length. It returns 0 if it fails, 1 on success.
653 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100654int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200655{
Willy Tarreau83061a82018-07-13 11:56:34 +0200656 struct buffer *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200657
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200658 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100659 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100660 case SMP_T_SINT:
661 case SMP_T_ADDR:
662 case SMP_T_IPV4:
663 case SMP_T_IPV6:
664 /* These type are not const. */
665 break;
Willy Tarreauad635822016-08-08 19:21:09 +0200666
Christopher Fauletec100512017-07-24 15:38:41 +0200667 case SMP_T_METH:
668 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
669 break;
670 /* Fall through */
671
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100672 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200673 trash = get_trash_chunk();
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100674 trash->data = smp->data.type == SMP_T_STR ?
675 smp->data.u.str.data : smp->data.u.meth.str.data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200676 if (trash->data > trash->size - 1)
677 trash->data = trash->size - 1;
Willy Tarreauad635822016-08-08 19:21:09 +0200678
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100679 memcpy(trash->area, smp->data.type == SMP_T_STR ?
680 smp->data.u.str.area : smp->data.u.meth.str.area,
681 trash->data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200682 trash->area[trash->data] = 0;
Willy Tarreauad635822016-08-08 19:21:09 +0200683 smp->data.u.str = *trash;
684 break;
685
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100686 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100687 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200688 trash->data = smp->data.u.str.data;
689 if (trash->data > trash->size)
690 trash->data = trash->size;
Willy Tarreauad635822016-08-08 19:21:09 +0200691
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200692 memcpy(trash->area, smp->data.u.str.area, trash->data);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200693 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100694 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200695
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100696 default:
697 /* Other cases are unexpected. */
698 return 0;
699 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100700
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100701 /* remove const flag */
702 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200703 return 1;
704}
705
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100706int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100707{
708 return 1;
709}
710
Willy Tarreau342acb42012-04-23 22:03:39 +0200711static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100712{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200713 const char *str;
714 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100715
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200716 if (smp->data.u.str.data == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100717 return 0;
718
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200719 str = smp->data.u.str.area;
720 end = smp->data.u.str.area + smp->data.u.str.data;
Emeric Brun107ca302010-01-04 16:16:05 +0100721
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200722 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200723 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100724 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100725 return 1;
726}
727
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100728static int c_str2meth(struct sample *smp)
729{
730 enum http_meth_t meth;
731 int len;
732
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200733 meth = find_http_meth(smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100734 if (meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200735 len = smp->data.u.str.data;
736 smp->data.u.meth.str.area = smp->data.u.str.area;
737 smp->data.u.meth.str.data = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100738 }
739 else
740 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200741 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200742 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100743 return 1;
744}
745
746static int c_meth2str(struct sample *smp)
747{
748 int len;
749 enum http_meth_t meth;
750
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200751 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100752 /* The method is unknown. Copy the original pointer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200753 len = smp->data.u.meth.str.data;
754 smp->data.u.str.area = smp->data.u.meth.str.area;
755 smp->data.u.str.data = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200756 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100757 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200758 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100759 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200760 meth = smp->data.u.meth.meth;
Willy Tarreau35b51c62018-09-10 15:38:55 +0200761 smp->data.u.str.area = http_known_methods[meth].ptr;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200762 smp->data.u.str.data = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100763 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200764 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100765 }
766 else {
767 /* Unknown method */
768 return 0;
769 }
770 return 1;
771}
772
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200773static int c_addr2bin(struct sample *smp)
774{
Willy Tarreau83061a82018-07-13 11:56:34 +0200775 struct buffer *chk = get_trash_chunk();
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200776
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200777 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200778 chk->data = 4;
779 memcpy(chk->area, &smp->data.u.ipv4, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200780 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200781 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200782 chk->data = 16;
783 memcpy(chk->area, &smp->data.u.ipv6, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200784 }
785 else
786 return 0;
787
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200788 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200789 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200790 return 1;
791}
792
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200793static int c_int2bin(struct sample *smp)
794{
Willy Tarreau83061a82018-07-13 11:56:34 +0200795 struct buffer *chk = get_trash_chunk();
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200796
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200797 *(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
798 chk->data = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200799
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200800 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200801 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200802 return 1;
803}
804
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200805
Emeric Brun107ca302010-01-04 16:16:05 +0100806/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200807/* Sample casts matrix: */
808/* sample_casts[from type][to type] */
809/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100810/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100811
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100812sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200813/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
814/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
815/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200816/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, c_int2ipv6, c_int2str, c_int2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200817/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
818/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200819/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200820/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
821/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
822/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200823};
Emeric Brun107ca302010-01-04 16:16:05 +0100824
Emeric Brun107ca302010-01-04 16:16:05 +0100825/*
Willy Tarreau12785782012-04-27 21:37:17 +0200826 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100827 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200828 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200829 * The caller must have set al->ctx.
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100830 * If <endptr> is non-nul, it will be set to the first unparsed character
831 * (which may be the final '\0') on success. If it is nul, the expression
832 * must be properly terminated by a '\0' otherwise an error is reported.
Emeric Brun107ca302010-01-04 16:16:05 +0100833 */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100834struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err_msg, struct arg_list *al, char **endptr)
Emeric Brun107ca302010-01-04 16:16:05 +0100835{
Willy Tarreau833cc792013-07-24 15:34:19 +0200836 const char *begw; /* beginning of word */
837 const char *endw; /* end of word */
838 const char *endt; /* end of term */
Remi Tricot-Le Breton54c88772021-01-12 14:55:12 +0100839 struct sample_expr *expr = NULL;
Willy Tarreau12785782012-04-27 21:37:17 +0200840 struct sample_fetch *fetch;
841 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100842 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200843 char *fkw = NULL;
844 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100845 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100846
Willy Tarreau833cc792013-07-24 15:34:19 +0200847 begw = str[*idx];
Willy Tarreaued2c6622020-02-14 18:27:10 +0100848 for (endw = begw; is_idchar(*endw); endw++)
849 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200850
851 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100852 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100853 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200854 }
Emeric Brun107ca302010-01-04 16:16:05 +0100855
Willy Tarreau833cc792013-07-24 15:34:19 +0200856 /* keep a copy of the current fetch keyword for error reporting */
857 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100858
Willy Tarreau833cc792013-07-24 15:34:19 +0200859 fetch = find_sample_fetch(begw, endw - begw);
860 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100861 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100862 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200863 }
Emeric Brun107ca302010-01-04 16:16:05 +0100864
Willy Tarreau833cc792013-07-24 15:34:19 +0200865 /* At this point, we have :
866 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100867 * - endw : end of the keyword, first character not part of keyword
Willy Tarreau833cc792013-07-24 15:34:19 +0200868 */
869
870 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100871 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100872 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200873 }
Emeric Brun107ca302010-01-04 16:16:05 +0100874 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200875
Vincent Bernat02779b62016-04-03 13:48:43 +0200876 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200877 if (!expr)
878 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100879
880 LIST_INIT(&(expr->conv_exprs));
881 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200882 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100883
Willy Tarreau689a1df2013-12-13 00:40:11 +0100884 /* Note that we call the argument parser even with an empty string,
885 * this allows it to automatically create entries for mandatory
886 * implicit arguments (eg: local proxy name).
887 */
888 al->kw = expr->fetch->kw;
889 al->conv = NULL;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100890 if (make_arg_list(endw, -1, fetch->arg_mask, &expr->arg_p, err_msg, &endt, &err_arg, al) < 0) {
Willy Tarreau689a1df2013-12-13 00:40:11 +0100891 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
892 goto out_error;
893 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200894
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100895 /* now endt is our first char not part of the arg list, typically the
896 * comma after the sample fetch name or after the closing parenthesis,
897 * or the NUL char.
898 */
899
Willy Tarreau689a1df2013-12-13 00:40:11 +0100900 if (!expr->arg_p) {
901 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200902 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100903 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
904 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200905 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100906 }
907
Willy Tarreau833cc792013-07-24 15:34:19 +0200908 /* Now process the converters if any. We have two supported syntaxes
909 * for the converters, which can be combined :
910 * - comma-delimited list of converters just after the keyword and args ;
911 * - one converter per keyword
912 * The combination allows to have each keyword being a comma-delimited
913 * series of converters.
914 *
915 * We want to process the former first, then the latter. For this we start
916 * from the beginning of the supposed place in the exiting conv chain, which
917 * starts at the last comma (endt).
918 */
919
920 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200921 struct sample_conv_expr *conv_expr;
Willy Tarreau46dfd782019-12-17 10:25:29 +0100922 int err_arg;
923 int argcnt;
Emeric Brun107ca302010-01-04 16:16:05 +0100924
Willy Tarreau833cc792013-07-24 15:34:19 +0200925 if (*endt && *endt != ',') {
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100926 if (endptr) {
927 /* end found, let's stop here */
928 break;
929 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200930 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100931 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200932 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100933 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100934 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200935 }
Emeric Brun107ca302010-01-04 16:16:05 +0100936
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100937 /* FIXME: how long should we support such idiocies ? Maybe we
938 * should already warn ?
939 */
Willy Tarreau833cc792013-07-24 15:34:19 +0200940 while (*endt == ',') /* then trailing commas */
941 endt++;
942
Willy Tarreau97108e02016-11-25 07:33:24 +0100943 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200944
945 if (!*begw) {
946 /* none ? skip to next string */
947 (*idx)++;
948 begw = str[*idx];
949 if (!begw || !*begw)
950 break;
951 }
952
Willy Tarreaued2c6622020-02-14 18:27:10 +0100953 for (endw = begw; is_idchar(*endw); endw++)
954 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200955
956 free(ckw);
957 ckw = my_strndup(begw, endw - begw);
958
959 conv = find_sample_conv(begw, endw - begw);
960 if (!conv) {
961 /* we found an isolated keyword that we don't know, it's not ours */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100962 if (begw == str[*idx]) {
963 endt = begw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200964 break;
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100965 }
Willy Tarreau97108e02016-11-25 07:33:24 +0100966 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200967 goto out_error;
968 }
Emeric Brun107ca302010-01-04 16:16:05 +0100969
Willy Tarreau833cc792013-07-24 15:34:19 +0200970 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100971 memprintf(err_msg, "returns type of converter '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100972 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200973 }
Emeric Brun107ca302010-01-04 16:16:05 +0100974
975 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200976 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100977 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100978 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200979 }
Emeric Brun107ca302010-01-04 16:16:05 +0100980
981 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +0200982 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200983 if (!conv_expr)
984 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100985
986 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
987 conv_expr->conv = conv;
988
Willy Tarreau46dfd782019-12-17 10:25:29 +0100989 al->kw = expr->fetch->kw;
990 al->conv = conv_expr->conv->kw;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100991 argcnt = make_arg_list(endw, -1, conv->arg_mask, &conv_expr->arg_p, err_msg, &endt, &err_arg, al);
Willy Tarreau46dfd782019-12-17 10:25:29 +0100992 if (argcnt < 0) {
993 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
994 goto out_error;
995 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100996
Willy Tarreau46dfd782019-12-17 10:25:29 +0100997 if (argcnt && !conv->arg_mask) {
998 memprintf(err_msg, "converter '%s' does not support any args", ckw);
999 goto out_error;
1000 }
Willy Tarreau21d68a62012-04-20 15:52:36 +02001001
Willy Tarreau46dfd782019-12-17 10:25:29 +01001002 if (!conv_expr->arg_p)
1003 conv_expr->arg_p = empty_arg_list;
Willy Tarreau2e845be2012-10-19 19:49:09 +02001004
Willy Tarreau46dfd782019-12-17 10:25:29 +01001005 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
1006 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001007 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001008 }
1009 }
Emeric Brun485479d2010-09-23 18:02:19 +02001010
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001011 if (endptr) {
1012 /* end found, let's stop here */
1013 *endptr = (char *)endt;
1014 }
1015
Willy Tarreau833cc792013-07-24 15:34:19 +02001016 out:
1017 free(fkw);
1018 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001019 return expr;
1020
1021out_error:
Remi Tricot-Le Breton54c88772021-01-12 14:55:12 +01001022 release_sample_expr(expr);
Willy Tarreau833cc792013-07-24 15:34:19 +02001023 expr = NULL;
1024 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001025}
1026
1027/*
Willy Tarreau12785782012-04-27 21:37:17 +02001028 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001029 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001030 * Returns a pointer on a typed sample structure containing the result or NULL if
1031 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001032 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001033 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001034 *
1035 * Note: the fetch functions are required to properly set the return type. The
1036 * conversion functions must do so too. However the cast functions do not need
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001037 * to since they're made to cast multiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001038 *
1039 * The caller may indicate in <opt> if it considers the result final or not.
1040 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1041 * if the result is stable or not, according to the following table :
1042 *
1043 * return MAY_CHANGE FINAL Meaning for the sample
1044 * NULL 0 * Not present and will never be (eg: header)
1045 * NULL 1 0 Not present yet, could change (eg: POST param)
1046 * NULL 1 1 Not present yet, will not change anymore
1047 * smp 0 * Present and will not change (eg: header)
1048 * smp 1 0 Present, may change (eg: request length)
1049 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001050 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001051struct sample *sample_process(struct proxy *px, struct session *sess,
1052 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001053 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001054{
Willy Tarreau12785782012-04-27 21:37:17 +02001055 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001056
Willy Tarreau18387e22013-07-25 12:02:38 +02001057 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001058 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001059 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001060 }
Emeric Brun107ca302010-01-04 16:16:05 +01001061
Willy Tarreau1777ea62016-03-10 16:15:46 +01001062 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001063 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001064 return NULL;
1065
Emeric Brun107ca302010-01-04 16:16:05 +01001066 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001067 /* we want to ensure that p->type can be casted into
1068 * conv_expr->conv->in_type. We have 3 possibilities :
1069 * - NULL => not castable.
1070 * - c_none => nothing to do (let's optimize it)
1071 * - other => apply cast and prepare to fail
1072 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001073 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001074 return NULL;
1075
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001076 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1077 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001078 return NULL;
1079
Willy Tarreau12e50112012-04-25 17:21:49 +02001080 /* OK cast succeeded */
1081
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001082 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001083 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001084 }
1085 return p;
1086}
1087
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001088/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001089 * Resolve all remaining arguments in proxy <p>. Returns the number of
1090 * errors or 0 if everything is fine.
1091 */
1092int smp_resolve_args(struct proxy *p)
1093{
1094 struct arg_list *cur, *bak;
1095 const char *ctx, *where;
1096 const char *conv_ctx, *conv_pre, *conv_pos;
1097 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001098 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001099 struct arg *arg;
1100 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001101 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001102
1103 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1104 struct proxy *px;
1105 struct server *srv;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001106 struct stktable *t;
1107 char *pname, *sname, *stktname;
Willy Tarreau46947782015-01-19 19:00:58 +01001108 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001109
1110 arg = cur->arg;
1111
1112 /* prepare output messages */
1113 conv_pre = conv_pos = conv_ctx = "";
1114 if (cur->conv) {
1115 conv_ctx = cur->conv;
1116 conv_pre = "conversion keyword '";
1117 conv_pos = "' for ";
1118 }
1119
1120 where = "in";
1121 ctx = "sample fetch keyword";
1122 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001123 case ARGC_STK: where = "in stick rule in"; break;
1124 case ARGC_TRK: where = "in tracking rule in"; break;
1125 case ARGC_LOG: where = "in log-format string in"; break;
1126 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1127 case ARGC_HRQ: where = "in http-request header format string in"; break;
1128 case ARGC_HRS: where = "in http-response header format string in"; break;
1129 case ARGC_UIF: where = "in unique-id-format string in"; break;
1130 case ARGC_RDR: where = "in redirect format string in"; break;
1131 case ARGC_CAP: where = "in capture rule in"; break;
1132 case ARGC_ACL: ctx = "ACL keyword"; break;
1133 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001134 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Christopher Faulet3b967c12020-05-15 15:47:44 +02001135 case ARGC_HERR: where = "in http-error directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001136 }
1137
1138 /* set a few default settings */
1139 px = p;
1140 pname = p->id;
1141
1142 switch (arg->type) {
1143 case ARGT_SRV:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001144 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001145 ha_alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1146 cur->file, cur->line,
1147 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001148 cfgerr++;
1149 continue;
1150 }
1151
1152 /* we support two formats : "bck/srv" and "srv" */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001153 sname = strrchr(arg->data.str.area, '/');
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001154
1155 if (sname) {
1156 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001157 pname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001158
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001159 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001160 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001161 ha_alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1162 cur->file, cur->line, pname,
1163 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001164 cfgerr++;
1165 break;
1166 }
1167 }
1168 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001169 sname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001170
1171 srv = findserver(px, sname);
1172 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001173 ha_alert("parsing [%s:%d] : unable to find server '%s' in proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1174 cur->file, cur->line, sname, pname,
1175 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001176 cfgerr++;
1177 break;
1178 }
1179
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001180 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001181 arg->unresolved = 0;
1182 arg->data.srv = srv;
1183 break;
1184
1185 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001186 if (arg->data.str.data) {
1187 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001188 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001189 }
1190
1191 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001192 ha_alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1193 cur->file, cur->line, pname,
1194 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001195 cfgerr++;
1196 break;
1197 }
1198
1199 if (!(px->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001200 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n",
1201 cur->file, cur->line, pname,
1202 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001203 cfgerr++;
1204 break;
1205 }
1206
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001207 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001208 arg->unresolved = 0;
1209 arg->data.prx = px;
1210 break;
1211
1212 case ARGT_BE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001213 if (arg->data.str.data) {
1214 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001215 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001216 }
1217
1218 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001219 ha_alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1220 cur->file, cur->line, pname,
1221 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001222 cfgerr++;
1223 break;
1224 }
1225
1226 if (!(px->cap & PR_CAP_BE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001227 ha_alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n",
1228 cur->file, cur->line, pname,
1229 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001230 cfgerr++;
1231 break;
1232 }
1233
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001234 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001235 arg->unresolved = 0;
1236 arg->data.prx = px;
1237 break;
1238
1239 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001240 if (arg->data.str.data)
1241 stktname = arg->data.str.area;
1242 else
1243 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001244
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001245 t = stktable_find_by_name(stktname);
1246 if (!t) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001247 ha_alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001248 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001249 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001250 cfgerr++;
1251 break;
1252 }
1253
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001254 if (!t->size) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001255 ha_alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001256 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001257 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001258 cfgerr++;
1259 break;
1260 }
1261
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001262 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001263 ha_alert("parsing [%s:%d] : stick-table '%s' not present on all processes covered by proxy '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001264 cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001265 cfgerr++;
1266 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001267 }
1268
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001269 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001270 p->next_stkt_ref = t->proxies_list;
1271 t->proxies_list = p;
1272 }
1273
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001274 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001275 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001276 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001277 break;
1278
1279 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001280 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001281 ha_alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1282 cur->file, cur->line,
1283 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001284 cfgerr++;
1285 break;
1286 }
1287
1288 if (p->uri_auth && p->uri_auth->userlist &&
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001289 !strcmp(p->uri_auth->userlist->name, arg->data.str.area))
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001290 ul = p->uri_auth->userlist;
1291 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001292 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001293
1294 if (!ul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001295 ha_alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001296 cur->file, cur->line,
1297 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001298 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001299 cfgerr++;
1300 break;
1301 }
1302
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001303 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001304 arg->unresolved = 0;
1305 arg->data.usr = ul;
1306 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001307
1308 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001309 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001310 ha_alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1311 cur->file, cur->line,
1312 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001313 cfgerr++;
1314 continue;
1315 }
1316
Willy Tarreau46947782015-01-19 19:00:58 +01001317 rflags = 0;
1318 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1319 err = NULL;
1320
Dragan Dosen26743032019-04-30 15:54:36 +02001321 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001322 ha_alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1323 cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001324 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001325 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
Willy Tarreau46947782015-01-19 19:00:58 +01001326 cfgerr++;
1327 continue;
1328 }
1329
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001330 chunk_destroy(&arg->data.str);
Willy Tarreau46947782015-01-19 19:00:58 +01001331 arg->unresolved = 0;
1332 arg->data.reg = reg;
1333 break;
1334
1335
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001336 }
1337
1338 LIST_DEL(&cur->list);
1339 free(cur);
1340 } /* end of args processing */
1341
1342 return cfgerr;
1343}
1344
1345/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001346 * Process a fetch + format conversion as defined by the sample expression
1347 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001348 * not explicitly set to <smp_type>, but shall be compatible with it as
1349 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1350 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001351 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1352 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1353 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1354 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001355 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1356 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1357 * still hope to get it after waiting longer, and is not converted to string.
1358 * The possible output combinations are the following :
1359 *
1360 * return MAY_CHANGE FINAL Meaning for the sample
1361 * NULL * * Not present and will never be (eg: header)
1362 * smp 0 * Final value converted (eg: header)
1363 * smp 1 0 Not present yet, may appear later (eg: header)
1364 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001365 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001366struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001367 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001368 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001369{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001370 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001371
Willy Tarreau6c616e02014-06-25 16:56:41 +02001372 memset(smp, 0, sizeof(*smp));
1373
Willy Tarreau192252e2015-04-04 01:47:55 +02001374 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001375 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1376 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001377 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001378 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001379
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001380 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001381 return NULL;
1382
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001383 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001384 return NULL;
1385
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001386 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001387 return smp;
1388}
1389
Christopher Faulet476e5d02016-10-26 11:34:47 +02001390static void release_sample_arg(struct arg *p)
1391{
1392 struct arg *p_back = p;
1393
1394 if (!p)
1395 return;
1396
1397 while (p->type != ARGT_STOP) {
1398 if (p->type == ARGT_STR || p->unresolved) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001399 chunk_destroy(&p->data.str);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001400 p->unresolved = 0;
1401 }
1402 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001403 regex_free(p->data.reg);
1404 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001405 }
1406 p++;
1407 }
1408
1409 if (p_back != empty_arg_list)
1410 free(p_back);
1411}
1412
1413void release_sample_expr(struct sample_expr *expr)
1414{
1415 struct sample_conv_expr *conv_expr, *conv_exprb;
1416
1417 if (!expr)
1418 return;
1419
Tim Duesterhus867cd982020-07-04 11:49:39 +02001420 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list) {
1421 LIST_DEL(&conv_expr->list);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001422 release_sample_arg(conv_expr->arg_p);
Tim Duesterhus867cd982020-07-04 11:49:39 +02001423 free(conv_expr);
1424 }
1425
Christopher Faulet476e5d02016-10-26 11:34:47 +02001426 release_sample_arg(expr->arg_p);
1427 free(expr);
1428}
1429
Emeric Brun107ca302010-01-04 16:16:05 +01001430/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001431/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001432/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001433/*****************************************************************/
1434
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001435static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1436{
1437 int i;
1438 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001439 struct buffer *buf;
1440 struct sink *sink;
1441 struct ist line;
1442 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001443
Willy Tarreau0851fd52019-12-17 10:07:25 +01001444 buf = alloc_trash_chunk();
1445 if (!buf)
1446 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001447
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001448 sink = (struct sink *)arg_p[1].data.ptr;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001449 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001450
Willy Tarreau0851fd52019-12-17 10:07:25 +01001451 pfx = arg_p[0].data.str.area;
1452 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001453
Willy Tarreau0851fd52019-12-17 10:07:25 +01001454 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1455 if (!sample_casts[smp->data.type][SMP_T_STR])
1456 goto nocast;
1457
1458 /* Copy sample fetch. This puts the sample as const, the
1459 * cast will copy data if a transformation is required.
1460 */
1461 memcpy(&tmp, smp, sizeof(struct sample));
1462 tmp.flags = SMP_F_CONST;
1463
1464 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1465 goto nocast;
1466
1467 /* Display the displayable chars*. */
1468 b_putchr(buf, '<');
1469 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001470 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001471 b_putchr(buf, tmp.data.u.str.area[i]);
1472 else
1473 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001474 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001475 b_putchr(buf, '>');
1476
1477 done:
1478 line = ist2(buf->area, buf->data);
Emeric Brun54648852020-07-06 15:54:06 +02001479 sink_write(sink, &line, 1, 0, 0, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001480 end:
1481 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001482 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001483 nocast:
1484 chunk_appendf(buf, "(undisplayable)");
1485 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001486}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001487
1488// This function checks the "debug" converter's arguments.
1489static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1490 const char *file, int line, char **err)
1491{
1492 const char *name = "buf0";
1493 struct sink *sink = NULL;
1494
1495 if (args[0].type != ARGT_STR) {
1496 /* optional prefix */
1497 args[0].data.str.area = "";
1498 args[0].data.str.data = 0;
1499 }
1500
1501 if (args[1].type == ARGT_STR)
1502 name = args[1].data.str.area;
1503
1504 sink = sink_find(name);
1505 if (!sink) {
1506 memprintf(err, "No such sink '%s'", name);
1507 return 0;
1508 }
1509
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001510 chunk_destroy(&args[1].data.str);
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001511 args[1].type = ARGT_PTR;
1512 args[1].data.ptr = sink;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001513 return 1;
1514}
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001515
Holger Just1bfc24b2017-05-06 00:56:53 +02001516static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1517{
Willy Tarreau83061a82018-07-13 11:56:34 +02001518 struct buffer *trash = get_trash_chunk();
Holger Just1bfc24b2017-05-06 00:56:53 +02001519 int bin_len;
1520
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001521 trash->data = 0;
1522 bin_len = base64dec(smp->data.u.str.area, smp->data.u.str.data,
1523 trash->area, trash->size);
Holger Just1bfc24b2017-05-06 00:56:53 +02001524 if (bin_len < 0)
1525 return 0;
1526
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001527 trash->data = bin_len;
Holger Just1bfc24b2017-05-06 00:56:53 +02001528 smp->data.u.str = *trash;
1529 smp->data.type = SMP_T_BIN;
1530 smp->flags &= ~SMP_F_CONST;
1531 return 1;
1532}
1533
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001534static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001535{
Willy Tarreau83061a82018-07-13 11:56:34 +02001536 struct buffer *trash = get_trash_chunk();
Emeric Brun53d1a982014-04-30 18:21:37 +02001537 int b64_len;
1538
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001539 trash->data = 0;
1540 b64_len = a2base64(smp->data.u.str.area, smp->data.u.str.data,
1541 trash->area, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001542 if (b64_len < 0)
1543 return 0;
1544
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001545 trash->data = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001546 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001547 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001548 smp->flags &= ~SMP_F_CONST;
1549 return 1;
1550}
1551
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001552static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1553{
1554 blk_SHA_CTX ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001555 struct buffer *trash = get_trash_chunk();
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001556
1557 memset(&ctx, 0, sizeof(ctx));
1558
1559 blk_SHA1_Init(&ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001560 blk_SHA1_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1561 blk_SHA1_Final((unsigned char *) trash->area, &ctx);
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001562
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001563 trash->data = 20;
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001564 smp->data.u.str = *trash;
1565 smp->data.type = SMP_T_BIN;
1566 smp->flags &= ~SMP_F_CONST;
1567 return 1;
1568}
1569
Tim Duesterhusd4376302019-06-17 12:41:44 +02001570#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01001571static int smp_check_sha2(struct arg *args, struct sample_conv *conv,
1572 const char *file, int line, char **err)
1573{
1574 if (args[0].type == ARGT_STOP)
1575 return 1;
1576 if (args[0].type != ARGT_SINT) {
1577 memprintf(err, "Invalid type '%s'", arg_type_names[args[0].type]);
1578 return 0;
1579 }
1580
1581 switch (args[0].data.sint) {
1582 case 224:
1583 case 256:
1584 case 384:
1585 case 512:
1586 /* this is okay */
1587 return 1;
1588 default:
1589 memprintf(err, "Unsupported number of bits: '%lld'", args[0].data.sint);
1590 return 0;
1591 }
1592}
1593
Tim Duesterhusd4376302019-06-17 12:41:44 +02001594static int sample_conv_sha2(const struct arg *arg_p, struct sample *smp, void *private)
1595{
1596 struct buffer *trash = get_trash_chunk();
1597 int bits = 256;
1598 if (arg_p && arg_p->data.sint)
1599 bits = arg_p->data.sint;
1600
1601 switch (bits) {
1602 case 224: {
1603 SHA256_CTX ctx;
1604
1605 memset(&ctx, 0, sizeof(ctx));
1606
1607 SHA224_Init(&ctx);
1608 SHA224_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1609 SHA224_Final((unsigned char *) trash->area, &ctx);
1610 trash->data = SHA224_DIGEST_LENGTH;
1611 break;
1612 }
1613 case 256: {
1614 SHA256_CTX ctx;
1615
1616 memset(&ctx, 0, sizeof(ctx));
1617
1618 SHA256_Init(&ctx);
1619 SHA256_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1620 SHA256_Final((unsigned char *) trash->area, &ctx);
1621 trash->data = SHA256_DIGEST_LENGTH;
1622 break;
1623 }
1624 case 384: {
1625 SHA512_CTX ctx;
1626
1627 memset(&ctx, 0, sizeof(ctx));
1628
1629 SHA384_Init(&ctx);
1630 SHA384_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1631 SHA384_Final((unsigned char *) trash->area, &ctx);
1632 trash->data = SHA384_DIGEST_LENGTH;
1633 break;
1634 }
1635 case 512: {
1636 SHA512_CTX ctx;
1637
1638 memset(&ctx, 0, sizeof(ctx));
1639
1640 SHA512_Init(&ctx);
1641 SHA512_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1642 SHA512_Final((unsigned char *) trash->area, &ctx);
1643 trash->data = SHA512_DIGEST_LENGTH;
1644 break;
1645 }
1646 default:
1647 return 0;
1648 }
1649
1650 smp->data.u.str = *trash;
1651 smp->data.type = SMP_T_BIN;
1652 smp->flags &= ~SMP_F_CONST;
1653 return 1;
1654}
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001655
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001656/* This function returns a sample struct filled with an <arg> content.
1657 * If the <arg> contains a string, it is returned in the sample flagged as
1658 * SMP_F_CONST. If the <arg> contains a variable descriptor, the sample is
1659 * filled with the content of the variable by using vars_get_by_desc().
1660 *
1661 * Keep in mind that the sample content may be written to a pre-allocated
1662 * trash chunk as returned by get_trash_chunk().
1663 *
1664 * This function returns 0 if an error occurs, otherwise it returns 1.
1665 */
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001666static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
1667{
1668 switch (arg->type) {
1669 case ARGT_STR:
1670 smp->data.type = SMP_T_STR;
1671 smp->data.u.str = arg->data.str;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001672 smp->flags = SMP_F_CONST;
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001673 return 1;
1674 case ARGT_VAR:
1675 if (!vars_get_by_desc(&arg->data.var, smp))
1676 return 0;
1677 if (!sample_casts[smp->data.type][SMP_T_STR])
1678 return 0;
1679 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
1680 return 0;
1681 return 1;
1682 default:
1683 return 0;
1684 }
1685}
1686
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001687/* This function checks an <arg> and fills it with a variable type if the
1688 * <arg> string contains a valid variable name. If failed, the function
1689 * tries to perform a base64 decode operation on the same string, and
1690 * fills the <arg> with the decoded content.
1691 *
1692 * Validation is skipped if the <arg> string is empty.
1693 *
1694 * This function returns 0 if the variable lookup fails and the specified
1695 * <arg> string is not a valid base64 encoded string, as well if
1696 * unexpected argument type is specified or memory allocation error
1697 * occurs. Otherwise it returns 1.
1698 */
1699static inline int sample_check_arg_base64(struct arg *arg, char **err)
1700{
1701 char *dec = NULL;
1702 int dec_size;
1703
1704 if (arg->type != ARGT_STR) {
1705 memprintf(err, "unexpected argument type");
1706 return 0;
1707 }
1708
1709 if (arg->data.str.data == 0) /* empty */
1710 return 1;
1711
1712 if (vars_check_arg(arg, NULL))
1713 return 1;
1714
1715 if (arg->data.str.data % 4) {
1716 memprintf(err, "argument needs to be base64 encoded, and "
1717 "can either be a string or a variable");
1718 return 0;
1719 }
1720
1721 dec_size = (arg->data.str.data / 4 * 3)
1722 - (arg->data.str.area[arg->data.str.data-1] == '=' ? 1 : 0)
1723 - (arg->data.str.area[arg->data.str.data-2] == '=' ? 1 : 0);
1724
1725 if ((dec = malloc(dec_size)) == NULL) {
1726 memprintf(err, "memory allocation error");
1727 return 0;
1728 }
1729
1730 dec_size = base64dec(arg->data.str.area, arg->data.str.data, dec, dec_size);
1731 if (dec_size < 0) {
1732 memprintf(err, "argument needs to be base64 encoded, and "
1733 "can either be a string or a variable");
1734 free(dec);
1735 return 0;
1736 }
1737
1738 /* base64 decoded */
1739 chunk_destroy(&arg->data.str);
1740 arg->data.str.area = dec;
1741 arg->data.str.data = dec_size;
1742 return 1;
1743}
1744
Patrick Gansterer8e366512020-04-22 16:47:57 +02001745#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001746static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
1747 const char *file, int line, char **err)
1748{
1749 switch(args[0].data.sint) {
1750 case 128:
1751 case 192:
1752 case 256:
1753 break;
1754 default:
1755 memprintf(err, "key size must be 128, 192 or 256 (bits).");
1756 return 0;
1757 }
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001758
1759 /* Try to decode variables. */
1760 if (!sample_check_arg_base64(&args[1], err)) {
1761 memprintf(err, "failed to parse nonce : %s", *err);
1762 return 0;
1763 }
1764 if (!sample_check_arg_base64(&args[2], err)) {
1765 memprintf(err, "failed to parse key : %s", *err);
1766 return 0;
1767 }
1768 if (!sample_check_arg_base64(&args[3], err)) {
1769 memprintf(err, "failed to parse aead_tag : %s", *err);
1770 return 0;
1771 }
1772
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001773 return 1;
1774}
1775
1776/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
1777static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
1778{
1779 struct sample nonce, key, aead_tag;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001780 struct buffer *smp_trash = NULL, *smp_trash_alloc = NULL;
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001781 EVP_CIPHER_CTX *ctx;
1782 int dec_size, ret;
1783
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001784 smp_trash_alloc = alloc_trash_chunk();
1785 if (!smp_trash_alloc)
1786 return 0;
1787
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001788 /* smp copy */
1789 smp_trash_alloc->data = smp->data.u.str.data;
1790 if (unlikely(smp_trash_alloc->data > smp_trash_alloc->size))
1791 smp_trash_alloc->data = smp_trash_alloc->size;
1792 memcpy(smp_trash_alloc->area, smp->data.u.str.area, smp_trash_alloc->data);
1793
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001794 ctx = EVP_CIPHER_CTX_new();
1795
1796 if (!ctx)
1797 goto err;
1798
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001799 smp_trash = alloc_trash_chunk();
1800 if (!smp_trash)
1801 goto err;
1802
1803 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
1804 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001805 goto err;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001806
1807 if (arg_p[1].type == ARGT_VAR) {
1808 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
1809 if (dec_size < 0)
1810 goto err;
1811 smp_trash->data = dec_size;
1812 nonce.data.u.str = *smp_trash;
1813 }
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001814
1815 /* Set cipher type and mode */
1816 switch(arg_p[0].data.sint) {
1817 case 128:
1818 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
1819 break;
1820 case 192:
1821 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
1822 break;
1823 case 256:
1824 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
1825 break;
1826 }
1827
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001828 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, nonce.data.u.str.data, NULL);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001829
1830 /* Initialise IV */
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001831 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) nonce.data.u.str.area))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001832 goto err;
1833
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001834 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1835 if (!sample_conv_var2smp_str(&arg_p[2], &key))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001836 goto err;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001837
1838 if (arg_p[2].type == ARGT_VAR) {
1839 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
1840 if (dec_size < 0)
1841 goto err;
1842 smp_trash->data = dec_size;
1843 key.data.u.str = *smp_trash;
1844 }
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001845
1846 /* Initialise key */
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001847 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) key.data.u.str.area, NULL))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001848 goto err;
1849
1850 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001851 (unsigned char *) smp_trash_alloc->area, (int) smp_trash_alloc->data))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001852 goto err;
1853
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001854 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
1855 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001856 goto err;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001857
1858 if (arg_p[3].type == ARGT_VAR) {
1859 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
1860 if (dec_size < 0)
1861 goto err;
1862 smp_trash_alloc->data = dec_size;
1863 aead_tag.data.u.str = *smp_trash_alloc;
1864 }
1865
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001866 dec_size = smp_trash->data;
1867
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001868 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 +02001869 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
1870
1871 if (ret <= 0)
1872 goto err;
1873
1874 smp->data.u.str.data = dec_size + smp_trash->data;
1875 smp->data.u.str.area = smp_trash->area;
1876 smp->data.type = SMP_T_BIN;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001877 smp_dup(smp);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001878 free_trash_chunk(smp_trash_alloc);
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001879 free_trash_chunk(smp_trash);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001880 return 1;
1881
1882err:
1883 free_trash_chunk(smp_trash_alloc);
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001884 free_trash_chunk(smp_trash);
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001885 return 0;
1886}
1887#endif /* HA_OPENSSL_VERSION_NUMBER */
1888
Patrick Gansterer8e366512020-04-22 16:47:57 +02001889static int check_crypto_digest(struct arg *args, struct sample_conv *conv,
1890 const char *file, int line, char **err)
1891{
1892 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1893
1894 if (evp)
1895 return 1;
1896
1897 memprintf(err, "algorithm must be a valid OpenSSL message digest name.");
1898 return 0;
1899}
1900
1901static int sample_conv_crypto_digest(const struct arg *args, struct sample *smp, void *private)
1902{
1903 struct buffer *trash = get_trash_chunk();
1904 unsigned char *md = (unsigned char*) trash->area;
1905 unsigned int md_len = trash->size;
1906 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
1907 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1908
1909 if (!ctx)
1910 return 0;
1911
1912 if (!EVP_DigestInit_ex(ctx, evp, NULL) ||
1913 !EVP_DigestUpdate(ctx, smp->data.u.str.area, smp->data.u.str.data) ||
1914 !EVP_DigestFinal_ex(ctx, md, &md_len)) {
1915 EVP_MD_CTX_free(ctx);
1916 return 0;
1917 }
1918
1919 EVP_MD_CTX_free(ctx);
1920
1921 trash->data = md_len;
1922 smp->data.u.str = *trash;
1923 smp->data.type = SMP_T_BIN;
1924 smp->flags &= ~SMP_F_CONST;
1925 return 1;
1926}
1927
1928static int check_crypto_hmac(struct arg *args, struct sample_conv *conv,
1929 const char *file, int line, char **err)
1930{
1931 if (!check_crypto_digest(args, conv, file, line, err))
1932 return 0;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001933
1934 if (!sample_check_arg_base64(&args[1], err)) {
1935 memprintf(err, "failed to parse key : %s", *err);
1936 return 0;
1937 }
Patrick Gansterer8e366512020-04-22 16:47:57 +02001938
Patrick Gansterer8e366512020-04-22 16:47:57 +02001939 return 1;
1940}
1941
1942static int sample_conv_crypto_hmac(const struct arg *args, struct sample *smp, void *private)
1943{
1944 struct sample key;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001945 struct buffer *trash = NULL, *key_trash = NULL;
Patrick Gansterer8e366512020-04-22 16:47:57 +02001946 unsigned char *md;
1947 unsigned int md_len;
1948 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1949 int dec_size;
1950
1951 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1952 if (!sample_conv_var2smp_str(&args[1], &key))
1953 return 0;
1954
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001955 if (args[1].type == ARGT_VAR) {
1956 key_trash = alloc_trash_chunk();
1957 if (!key_trash)
1958 goto err;
1959
1960 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, key_trash->area, key_trash->size);
1961 if (dec_size < 0)
1962 goto err;
1963 key_trash->data = dec_size;
1964 key.data.u.str = *key_trash;
1965 }
Patrick Gansterer8e366512020-04-22 16:47:57 +02001966
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001967 trash = alloc_trash_chunk();
1968 if (!trash)
Patrick Gansterer8e366512020-04-22 16:47:57 +02001969 goto err;
1970
1971 md = (unsigned char*) trash->area;
1972 md_len = trash->size;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001973 if (!HMAC(evp, key.data.u.str.area, key.data.u.str.data, (const unsigned char*) smp->data.u.str.area,
1974 smp->data.u.str.data, md, &md_len))
Patrick Gansterer8e366512020-04-22 16:47:57 +02001975 goto err;
1976
1977 free_trash_chunk(key_trash);
1978
1979 trash->data = md_len;
1980 smp->data.u.str = *trash;
1981 smp->data.type = SMP_T_BIN;
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001982 smp_dup(smp);
1983 free_trash_chunk(trash);
Patrick Gansterer8e366512020-04-22 16:47:57 +02001984 return 1;
1985
1986err:
1987 free_trash_chunk(key_trash);
Dragan Dosen11a23ed2021-02-22 10:03:53 +01001988 free_trash_chunk(trash);
Patrick Gansterer8e366512020-04-22 16:47:57 +02001989 return 0;
1990}
1991
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001992#endif /* USE_OPENSSL */
Tim Duesterhusd4376302019-06-17 12:41:44 +02001993
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001994static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001995{
Willy Tarreau83061a82018-07-13 11:56:34 +02001996 struct buffer *trash = get_trash_chunk();
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001997 unsigned char c;
1998 int ptr = 0;
1999
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002000 trash->data = 0;
2001 while (ptr < smp->data.u.str.data && trash->data <= trash->size - 2) {
2002 c = smp->data.u.str.area[ptr++];
2003 trash->area[trash->data++] = hextab[(c >> 4) & 0xF];
2004 trash->area[trash->data++] = hextab[c & 0xF];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002005 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002006 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002007 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002008 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01002009 return 1;
2010}
2011
Dragan Dosen3f957b22017-10-24 09:27:34 +02002012static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
2013{
2014 long long int n = 0;
2015 int i, c;
2016
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002017 for (i = 0; i < smp->data.u.str.data; i++) {
2018 if ((c = hex2i(smp->data.u.str.area[i])) < 0)
Dragan Dosen3f957b22017-10-24 09:27:34 +02002019 return 0;
2020 n = (n << 4) + c;
2021 }
2022
2023 smp->data.u.sint = n;
2024 smp->data.type = SMP_T_SINT;
2025 smp->flags &= ~SMP_F_CONST;
2026 return 1;
2027}
2028
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002029/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002030static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002031{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002032 smp->data.u.sint = hash_djb2(smp->data.u.str.area,
2033 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002034 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002035 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002036 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002037 return 1;
2038}
2039
Willy Tarreau60a2ee72017-12-15 07:13:48 +01002040static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01002041{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002042 int i = smp->data.u.str.data;
Etienne Carriereed0d24e2017-12-13 13:41:34 +01002043 smp->data.u.sint = i;
2044 smp->data.type = SMP_T_SINT;
2045 return 1;
2046}
2047
2048
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002049static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01002050{
2051 int i;
2052
Willy Tarreauf0645dc2016-08-09 14:29:38 +02002053 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01002054 return 0;
2055
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002056 for (i = 0; i < smp->data.u.str.data; i++) {
2057 if ((smp->data.u.str.area[i] >= 'A') && (smp->data.u.str.area[i] <= 'Z'))
2058 smp->data.u.str.area[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01002059 }
2060 return 1;
2061}
2062
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002063static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01002064{
2065 int i;
2066
Willy Tarreauf0645dc2016-08-09 14:29:38 +02002067 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02002068 return 0;
2069
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002070 for (i = 0; i < smp->data.u.str.data; i++) {
2071 if ((smp->data.u.str.area[i] >= 'a') && (smp->data.u.str.area[i] <= 'z'))
2072 smp->data.u.str.area[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01002073 }
2074 return 1;
2075}
2076
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002077/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
2078static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01002079{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01002080 /* Attempt to convert to IPv4 to apply the correct mask. */
2081 c_ipv62ip(smp);
2082
2083 if (smp->data.type == SMP_T_IPV4) {
2084 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
2085 smp->data.type = SMP_T_IPV4;
2086 }
2087 else if (smp->data.type == SMP_T_IPV6) {
2088 /* IPv6 cannot be converted without an IPv6 mask. */
2089 if (args[1].type != ARGT_IPV6)
2090 return 0;
2091
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +01002092 write_u64(&smp->data.u.ipv6.s6_addr[0],
2093 read_u64(&smp->data.u.ipv6.s6_addr[0]) & read_u64(&args[1].data.ipv6.s6_addr[0]));
2094 write_u64(&smp->data.u.ipv6.s6_addr[8],
2095 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 +01002096 smp->data.type = SMP_T_IPV6;
2097 }
2098
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01002099 return 1;
2100}
2101
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002102/* takes an UINT value on input supposed to represent the time since EPOCH,
2103 * adds an optional offset found in args[1] and emits a string representing
2104 * the local time in the format specified in args[1] using strftime().
2105 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002106static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002107{
Willy Tarreau83061a82018-07-13 11:56:34 +02002108 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002109 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002110 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002111 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002112
2113 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002114 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002115 curr_date += args[1].data.sint;
2116
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002117 tm = localtime(&curr_date);
2118 if (!tm)
2119 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002120 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002121 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2122 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002123 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002124 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002125 return 1;
2126}
2127
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002128/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002129static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002130{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002131 smp->data.u.sint = hash_sdbm(smp->data.u.str.area,
2132 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002133 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002134 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002135 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002136 return 1;
2137}
2138
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002139/* takes an UINT value on input supposed to represent the time since EPOCH,
2140 * adds an optional offset found in args[1] and emits a string representing
2141 * the UTC date in the format specified in args[1] using strftime().
2142 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002143static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002144{
Willy Tarreau83061a82018-07-13 11:56:34 +02002145 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002146 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002147 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002148 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002149
2150 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002151 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002152 curr_date += args[1].data.sint;
2153
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002154 tm = gmtime(&curr_date);
2155 if (!tm)
2156 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002157 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002158 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2159 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002160 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002161 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002162 return 1;
2163}
2164
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002165/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002166static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002167{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002168 smp->data.u.sint = hash_wt6(smp->data.u.str.area,
2169 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002170 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002171 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002172 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002173 return 1;
2174}
2175
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002176/* hashes the binary input into a 32-bit unsigned int using xxh.
2177 * The seed of the hash defaults to 0 but can be changd in argument 1.
2178 */
2179static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
2180{
2181 unsigned int seed;
2182
2183 if (arg_p && arg_p->data.sint)
2184 seed = arg_p->data.sint;
2185 else
2186 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002187 smp->data.u.sint = XXH32(smp->data.u.str.area, smp->data.u.str.data,
2188 seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002189 smp->data.type = SMP_T_SINT;
2190 return 1;
2191}
2192
2193/* hashes the binary input into a 64-bit unsigned int using xxh.
2194 * In fact, the function returns a 64 bit unsigned, but the sample
2195 * storage of haproxy only proposes 64-bits signed, so the value is
2196 * cast as signed. This cast doesn't impact the hash repartition.
2197 * The seed of the hash defaults to 0 but can be changd in argument 1.
2198 */
2199static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
2200{
2201 unsigned long long int seed;
2202
2203 if (arg_p && arg_p->data.sint)
2204 seed = (unsigned long long int)arg_p->data.sint;
2205 else
2206 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002207 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.area,
2208 smp->data.u.str.data, seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002209 smp->data.type = SMP_T_SINT;
2210 return 1;
2211}
2212
Willy Tarreau80599772015-01-20 19:35:24 +01002213/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002214static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002215{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002216 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2217 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002218 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002219 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002220 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002221 return 1;
2222}
2223
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002224/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2225static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2226{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002227 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2228 smp->data.u.str.data);
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002229 if (arg_p && arg_p->data.sint)
2230 smp->data.u.sint = full_hash(smp->data.u.sint);
2231 smp->data.type = SMP_T_SINT;
2232 return 1;
2233}
2234
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002235/* This function escape special json characters. The returned string can be
2236 * safely set between two '"' and used as json string. The json string is
2237 * defined like this:
2238 *
2239 * any Unicode character except '"' or '\' or control character
2240 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2241 *
2242 * The enum input_type contain all the allowed mode for decoding the input
2243 * string.
2244 */
2245enum input_type {
2246 IT_ASCII = 0,
2247 IT_UTF8,
2248 IT_UTF8S,
2249 IT_UTF8P,
2250 IT_UTF8PS,
2251};
2252static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2253 const char *file, int line, char **err)
2254{
Christopher Faulet95917132020-08-05 23:07:07 +02002255 enum input_type type;
2256
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002257 if (!arg) {
2258 memprintf(err, "Unexpected empty arg list");
2259 return 0;
2260 }
2261
2262 if (arg->type != ARGT_STR) {
2263 memprintf(err, "Unexpected arg type");
2264 return 0;
2265 }
2266
Christopher Faulet95917132020-08-05 23:07:07 +02002267 if (strcmp(arg->data.str.area, "") == 0)
2268 type = IT_ASCII;
2269 else if (strcmp(arg->data.str.area, "ascii") == 0)
2270 type = IT_ASCII;
2271 else if (strcmp(arg->data.str.area, "utf8") == 0)
2272 type = IT_UTF8;
2273 else if (strcmp(arg->data.str.area, "utf8s") == 0)
2274 type = IT_UTF8S;
2275 else if (strcmp(arg->data.str.area, "utf8p") == 0)
2276 type = IT_UTF8P;
2277 else if (strcmp(arg->data.str.area, "utf8ps") == 0)
2278 type = IT_UTF8PS;
2279 else {
2280 memprintf(err, "Unexpected input code type. "
2281 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
2282 return 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002283 }
2284
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002285 chunk_destroy(&arg->data.str);
Christopher Faulet95917132020-08-05 23:07:07 +02002286 arg->type = ARGT_SINT;
2287 arg->data.sint = type;
2288 return 1;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002289}
2290
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002291static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002292{
Willy Tarreau83061a82018-07-13 11:56:34 +02002293 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002294 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2295 const char *str;
2296 int len;
2297 enum input_type input_type = IT_ASCII;
2298 unsigned int c;
2299 unsigned int ret;
2300 char *p;
2301
2302 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002303 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002304
2305 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002306 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002307
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002308 p = smp->data.u.str.area;
2309 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002310
2311 if (input_type == IT_ASCII) {
2312 /* Read input as ASCII. */
2313 c = *(unsigned char *)p;
2314 p++;
2315 }
2316 else {
2317 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002318 ret = utf8_next(p,
2319 smp->data.u.str.data - ( p - smp->data.u.str.area),
2320 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002321 p += utf8_return_length(ret);
2322
2323 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2324 return 0;
2325 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2326 continue;
2327 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2328 return 0;
2329 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2330 continue;
2331
2332 /* Check too big values. */
2333 if ((unsigned int)c > 0xffff) {
2334 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2335 return 0;
2336 continue;
2337 }
2338 }
2339
2340 /* Convert character. */
2341 if (c == '"') {
2342 len = 2;
2343 str = "\\\"";
2344 }
2345 else if (c == '\\') {
2346 len = 2;
2347 str = "\\\\";
2348 }
2349 else if (c == '/') {
2350 len = 2;
2351 str = "\\/";
2352 }
2353 else if (c == '\b') {
2354 len = 2;
2355 str = "\\b";
2356 }
2357 else if (c == '\f') {
2358 len = 2;
2359 str = "\\f";
2360 }
2361 else if (c == '\r') {
2362 len = 2;
2363 str = "\\r";
2364 }
2365 else if (c == '\n') {
2366 len = 2;
2367 str = "\\n";
2368 }
2369 else if (c == '\t') {
2370 len = 2;
2371 str = "\\t";
2372 }
Willy Tarreau90807112020-02-25 08:16:33 +01002373 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002374 /* isprint generate a segfault if c is too big. The man says that
2375 * c must have the value of an unsigned char or EOF.
2376 */
2377 len = 6;
2378 _str[0] = '\\';
2379 _str[1] = 'u';
2380 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2381 str = _str;
2382 }
2383 else {
2384 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002385 _str[0] = c;
2386 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002387 }
2388
2389 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002390 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002391 return 0;
2392
2393 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002394 memcpy(temp->area + temp->data, str, len);
2395 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002396 }
2397
2398 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002399 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002400 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002401
2402 return 1;
2403}
2404
Emeric Brun54c4ac82014-11-03 15:32:43 +01002405/* This sample function is designed to extract some bytes from an input buffer.
2406 * First arg is the offset.
2407 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002408static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002409{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002410 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2411 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002412 return 1;
2413 }
2414
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002415 if (smp->data.u.str.size)
2416 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002417 smp->data.u.str.data -= arg_p[0].data.sint;
2418 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002419
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002420 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2421 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002422
2423 return 1;
2424}
2425
Emeric Brunf399b0d2014-11-03 17:07:03 +01002426static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2427 const char *file, int line, char **err)
2428{
2429 struct arg *arg = args;
2430
2431 if (!arg) {
2432 memprintf(err, "Unexpected empty arg list");
2433 return 0;
2434 }
2435
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002436 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002437 memprintf(err, "Unexpected arg type");
2438 return 0;
2439 }
2440
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002441 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002442 memprintf(err, "Unexpected value 0 for index");
2443 return 0;
2444 }
2445
2446 arg++;
2447
2448 if (arg->type != ARGT_STR) {
2449 memprintf(err, "Unexpected arg type");
2450 return 0;
2451 }
2452
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002453 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002454 memprintf(err, "Empty separators list");
2455 return 0;
2456 }
2457
2458 return 1;
2459}
2460
2461/* This sample function is designed to a return selected part of a string (field).
2462 * First arg is the index of the field (start at 1)
2463 * Second arg is a char list of separators (type string)
2464 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002465static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002466{
Marcin Deranek9631a282018-04-16 14:30:46 +02002467 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002468 char *start, *end;
2469 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002470 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002471
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002472 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002473 return 0;
2474
Marcin Deranek9631a282018-04-16 14:30:46 +02002475 if (arg_p[0].data.sint < 0) {
2476 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002477 end = start = smp->data.u.str.area + smp->data.u.str.data;
2478 while (start > smp->data.u.str.area) {
2479 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2480 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002481 if (field == arg_p[0].data.sint) {
2482 if (count == 1)
2483 goto found;
2484 else if (count > 1)
2485 count--;
2486 } else {
2487 end = start-1;
2488 field--;
2489 }
2490 break;
2491 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002492 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002493 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002494 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002495 } else {
2496 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002497 end = start = smp->data.u.str.area;
2498 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2499 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2500 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002501 if (field == arg_p[0].data.sint) {
2502 if (count == 1)
2503 goto found;
2504 else if (count > 1)
2505 count--;
2506 } else {
2507 start = end+1;
2508 field++;
2509 }
2510 break;
2511 }
2512 }
2513 end++;
2514 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002515 }
2516
2517 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002518 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002519 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002520 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002521 }
2522found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002523 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002524 /* If ret string is len 0, no need to
2525 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002526 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002527 return 1;
2528
Emeric Brunf399b0d2014-11-03 17:07:03 +01002529 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002530 Note: smp->data.u.str.size cannot be set to 0 */
2531 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002532 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002533
Thayne McCombsffa78462021-04-11 23:26:59 -06002534 smp->data.u.str.area = start;
2535
Emeric Brunf399b0d2014-11-03 17:07:03 +01002536 return 1;
2537}
2538
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002539/* This sample function is designed to return a word from a string.
2540 * First arg is the index of the word (start at 1)
2541 * Second arg is a char list of words separators (type string)
2542 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002543static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002544{
Marcin Deranek9631a282018-04-16 14:30:46 +02002545 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002546 char *start, *end;
2547 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002548 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002549
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002550 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002551 return 0;
2552
2553 word = 0;
2554 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002555 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002556 end = start = smp->data.u.str.area + smp->data.u.str.data;
2557 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002558 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002559 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2560 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002561 issep = 1;
2562 break;
2563 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002564 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002565 if (!inword) {
2566 if (!issep) {
2567 if (word != arg_p[0].data.sint) {
2568 word--;
2569 end = start;
2570 }
2571 inword = 1;
2572 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002573 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002574 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002575 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002576 if (count == 1)
2577 goto found;
2578 else if (count > 1)
2579 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002580 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002581 inword = 0;
2582 }
2583 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002584 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002585 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002586 end = start = smp->data.u.str.area;
2587 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002588 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002589 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2590 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002591 issep = 1;
2592 break;
2593 }
2594 }
2595 if (!inword) {
2596 if (!issep) {
2597 if (word != arg_p[0].data.sint) {
2598 word++;
2599 start = end;
2600 }
2601 inword = 1;
2602 }
2603 }
2604 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002605 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002606 if (count == 1)
2607 goto found;
2608 else if (count > 1)
2609 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002610 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002611 inword = 0;
2612 }
2613 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002614 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002615 }
2616
2617 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002618 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002619 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002620 return 1;
2621 }
2622found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002623 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002624 /* If ret string is len 0, no need to
2625 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002626 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002627 return 1;
2628
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002629 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002630
2631 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002632 Note: smp->data.u.str.size cannot be set to 0 */
2633 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002634 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002635
2636 return 1;
2637}
2638
Willy Tarreau7eda8492015-01-20 19:47:06 +01002639static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2640 const char *file, int line, char **err)
2641{
2642 struct arg *arg = args;
2643 char *p;
2644 int len;
2645
2646 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2647 arg[0].type_flags = 0;
2648
2649 if (arg[2].type != ARGT_STR)
2650 return 1;
2651
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002652 p = arg[2].data.str.area;
2653 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002654 while (len) {
2655 if (*p == 'i') {
2656 arg[0].type_flags |= ARGF_REG_ICASE;
2657 }
2658 else if (*p == 'g') {
2659 arg[0].type_flags |= ARGF_REG_GLOB;
2660 }
2661 else {
2662 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2663 return 0;
2664 }
2665 p++;
2666 len--;
2667 }
2668 return 1;
2669}
2670
2671/* This sample function is designed to do the equivalent of s/match/replace/ on
2672 * the input string. It applies a regex and restarts from the last matched
2673 * location until nothing matches anymore. First arg is the regex to apply to
2674 * the input string, second arg is the replacement expression.
2675 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002676static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002677{
2678 char *start, *end;
2679 struct my_regex *reg = arg_p[0].data.reg;
2680 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002681 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002682 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002683 int flag, max;
2684 int found;
2685
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002686 start = smp->data.u.str.area;
2687 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002688
2689 flag = 0;
2690 while (1) {
2691 /* check for last round which is used to copy remaining parts
2692 * when not running in global replacement mode.
2693 */
2694 found = 0;
2695 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2696 /* Note: we can have start == end on empty strings or at the end */
2697 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2698 }
2699
2700 if (!found)
2701 pmatch[0].rm_so = end - start;
2702
2703 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002704 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002705 if (max && pmatch[0].rm_so > 0) {
2706 if (max > pmatch[0].rm_so)
2707 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002708 memcpy(trash->area + trash->data, start, max);
2709 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002710 }
2711
2712 if (!found)
2713 break;
2714
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002715 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002716 if (!output)
2717 break;
2718
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002719 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2720
Willy Tarreau7eda8492015-01-20 19:47:06 +01002721 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002722 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002723 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002724 if (max > output->data)
2725 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002726 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002727 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002728 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002729 }
2730
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002731 free_trash_chunk(output);
2732
Willy Tarreau7eda8492015-01-20 19:47:06 +01002733 /* stop here if we're done with this string */
2734 if (start >= end)
2735 break;
2736
2737 /* We have a special case for matches of length 0 (eg: "x*y*").
2738 * These ones are considered to match in front of a character,
2739 * so we have to copy that character and skip to the next one.
2740 */
2741 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002742 if (trash->data < trash->size)
2743 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002744 pmatch[0].rm_eo++;
2745 }
2746
2747 start += pmatch[0].rm_eo;
2748 flag |= REG_NOTBOL;
2749 }
2750
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002751 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002752 return 1;
2753}
2754
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002755/* This function check an operator entry. It expects a string.
2756 * The string can be an integer or a variable name.
2757 */
2758static int check_operator(struct arg *args, struct sample_conv *conv,
2759 const char *file, int line, char **err)
2760{
2761 const char *str;
2762 const char *end;
Christopher Faulet95917132020-08-05 23:07:07 +02002763 long long int i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002764
2765 /* Try to decode a variable. */
2766 if (vars_check_arg(&args[0], NULL))
2767 return 1;
2768
2769 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002770 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002771 end = str + strlen(str);
Christopher Faulet95917132020-08-05 23:07:07 +02002772 i = read_int64(&str, end);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002773 if (*str != '\0') {
2774 memprintf(err, "expects an integer or a variable name");
2775 return 0;
2776 }
Christopher Faulet95917132020-08-05 23:07:07 +02002777
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002778 chunk_destroy(&args[0].data.str);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002779 args[0].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02002780 args[0].data.sint = i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002781 return 1;
2782}
2783
Willy Tarreau6204cd92016-03-10 16:33:04 +01002784/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002785 * If the arg contain an integer, the integer is returned in the
2786 * sample. If the arg contains a variable descriptor, it returns the
2787 * variable value.
2788 *
2789 * This function returns 0 if an error occurs, otherwise it returns 1.
2790 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002791static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002792{
2793 switch (arg->type) {
2794 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002795 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002796 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002797 return 1;
2798 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002799 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002800 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002801 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002802 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002803 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002804 return 0;
2805 return 1;
2806 default:
2807 return 0;
2808 }
2809}
2810
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002811/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002812 * result.
2813 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002814static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002815{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002816 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002817 return 1;
2818}
2819
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002820/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002821 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002822 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002823static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002824{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002825 struct sample tmp;
2826
Willy Tarreau7560dd42016-03-10 16:28:58 +01002827 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002828 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002829 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002830 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002831 return 1;
2832}
2833
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002834/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002835 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002836 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002837static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002838{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002839 struct sample tmp;
2840
Willy Tarreau7560dd42016-03-10 16:28:58 +01002841 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002842 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002843 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002844 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002845 return 1;
2846}
2847
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002848/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002849 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002850 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002851static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002852{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002853 struct sample tmp;
2854
Willy Tarreau7560dd42016-03-10 16:28:58 +01002855 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002856 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002857 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002858 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002859 return 1;
2860}
2861
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002862static inline long long int arith_add(long long int a, long long int b)
2863{
2864 /* Prevent overflow and makes capped calculus.
2865 * We must ensure that the check calculus doesn't
2866 * exceed the signed 64 bits limits.
2867 *
2868 * +----------+----------+
2869 * | a<0 | a>=0 |
2870 * +------+----------+----------+
2871 * | b<0 | MIN-a>b | no check |
2872 * +------+----------+----------+
2873 * | b>=0 | no check | MAX-a<b |
2874 * +------+----------+----------+
2875 */
2876 if ((a ^ b) >= 0) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002877 /* signs are different. */
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002878 if (a < 0) {
2879 if (LLONG_MIN - a > b)
2880 return LLONG_MIN;
2881 }
2882 if (LLONG_MAX - a < b)
2883 return LLONG_MAX;
2884 }
2885 return a + b;
2886}
2887
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002888/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002889 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002890 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002891static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002892{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002893 struct sample tmp;
2894
Willy Tarreau7560dd42016-03-10 16:28:58 +01002895 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002896 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002897 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002898 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002899 return 1;
2900}
2901
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002902/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002903 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002904 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002905static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002906 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002907{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002908 struct sample tmp;
2909
Willy Tarreau7560dd42016-03-10 16:28:58 +01002910 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002911 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002912 return 0;
2913
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002914 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2915 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2916 * of -LLONG_MIN and correct the result.
2917 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002918 if (tmp.data.u.sint == LLONG_MIN) {
2919 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2920 if (smp->data.u.sint < LLONG_MAX)
2921 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002922 return 1;
2923 }
2924
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002925 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002926 * the second operand.
2927 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002928 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002929 return 1;
2930}
2931
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002932/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002933 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002934 * If the result makes an overflow, then the largest possible quantity is
2935 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002936 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002937static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002938 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002939{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002940 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002941 long long int c;
2942
Willy Tarreau7560dd42016-03-10 16:28:58 +01002943 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002944 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002945 return 0;
2946
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002947 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002948 if (!smp->data.u.sint || !tmp.data.u.sint) {
2949 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002950 return 1;
2951 }
2952
2953 /* The multiply between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002954 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002955 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002956 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2957 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002958 return 1;
2959 }
2960
2961 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002962 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002963
2964 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002965 if (smp->data.u.sint != c / tmp.data.u.sint) {
2966 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2967 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002968 return 1;
2969 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002970 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002971 return 1;
2972 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002973 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002974 return 1;
2975}
2976
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002977/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002978 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002979 * If arg_p makes the result overflow, then the largest possible quantity is
2980 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002981 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002982static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002983 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002984{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002985 struct sample tmp;
2986
Willy Tarreau7560dd42016-03-10 16:28:58 +01002987 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002988 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002989 return 0;
2990
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002991 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002992 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002993 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002994 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002995 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2996 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002997 return 1;
2998 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002999 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003000 return 1;
3001 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003002 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01003003 return 1;
3004}
3005
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003006/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08003007 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003008 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01003009 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003010static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003011 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003012{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003013 struct sample tmp;
3014
Willy Tarreau7560dd42016-03-10 16:28:58 +01003015 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01003016 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003017 return 0;
3018
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003019 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003020 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05003021 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003022 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003023 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
3024 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003025 return 1;
3026 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003027 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003028 return 1;
3029 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003030 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01003031 return 1;
3032}
3033
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003034/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01003035 * result.
3036 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003037static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003038 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003039{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003040 if (smp->data.u.sint == LLONG_MIN)
3041 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02003042 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003043 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01003044 return 1;
3045}
3046
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003047/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01003048 * false. The output is a BOOL.
3049 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003050static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003051 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003052{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003053 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003054 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003055 return 1;
3056}
3057
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003058/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01003059 * truee. The output is a BOOL.
3060 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003061static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003062 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003063{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003064 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003065 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003066 return 1;
3067}
3068
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003069/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01003070 * The output is a BOOL.
3071 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003072static int sample_conv_arith_odd(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 FOURNIER136f9d32015-08-19 09:07:19 +02003075 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003076 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003077 return 1;
3078}
3079
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003080/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01003081 * The output is a BOOL.
3082 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003083static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01003084 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01003085{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003086 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003087 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01003088 return 1;
3089}
3090
Willy Tarreau280f42b2018-02-19 15:34:12 +01003091/* appends an optional const string, an optional variable contents and another
3092 * optional const string to an existing string.
3093 */
3094static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
3095{
Willy Tarreau83061a82018-07-13 11:56:34 +02003096 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003097 struct sample tmp;
3098 int max;
3099
Willy Tarreau79f43602021-01-08 16:08:43 +01003100 trash = alloc_trash_chunk();
William Dauchyc9656832021-01-11 11:05:58 +01003101 if (!trash)
3102 return 0;
3103
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003104 trash->data = smp->data.u.str.data;
3105 if (trash->data > trash->size - 1)
3106 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003107
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003108 memcpy(trash->area, smp->data.u.str.area, trash->data);
3109 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003110
3111 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003112 max = arg_p[0].data.str.data;
3113 if (max > trash->size - 1 - trash->data)
3114 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003115
3116 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003117 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3118 trash->data += max;
3119 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003120 }
3121
3122 /* append second string (variable) if it's found and we can turn it
3123 * into a string.
3124 */
3125 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3126 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3127 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3128 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3129
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003130 max = tmp.data.u.str.data;
3131 if (max > trash->size - 1 - trash->data)
3132 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003133
3134 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003135 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3136 max);
3137 trash->data += max;
3138 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003139 }
3140 }
3141
3142 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003143 max = arg_p[2].data.str.data;
3144 if (max > trash->size - 1 - trash->data)
3145 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003146
3147 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003148 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3149 trash->data += max;
3150 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003151 }
3152
3153 smp->data.u.str = *trash;
3154 smp->data.type = SMP_T_STR;
Willy Tarreau79f43602021-01-08 16:08:43 +01003155 smp_dup(smp);
3156 free_trash_chunk(trash);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003157 return 1;
3158}
3159
3160/* This function checks the "concat" converter's arguments and extracts the
3161 * variable name and its scope.
3162 */
3163static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3164 const char *file, int line, char **err)
3165{
3166 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003167 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3168 memprintf(err, "failed to register variable name '%s'",
3169 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003170 return 0;
3171 }
3172 return 1;
3173}
3174
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003175/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003176 * is compatible with strcmp(3)'s return value.
3177 */
3178static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3179{
3180 struct sample tmp;
3181 int max, result;
3182
3183 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3184 if (arg_p[0].type != ARGT_VAR)
3185 return 0;
3186 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3187 return 0;
3188 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3189 return 0;
3190
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003191 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3192 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003193 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003194 if (smp->data.u.str.data != tmp.data.u.str.data) {
3195 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003196 result = -1;
3197 }
3198 else {
3199 result = 1;
3200 }
3201 }
3202 }
3203
3204 smp->data.u.sint = result;
3205 smp->data.type = SMP_T_SINT;
3206 return 1;
3207}
3208
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003209#ifdef USE_OPENSSL
3210/* Compares bytestring with a variable containing a bytestring. Return value
3211 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3212 *
3213 * Comparison will be performed in constant time if both bytestrings are of
3214 * the same length. If the lengths differ execution time will not be constant.
3215 */
3216static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3217{
3218 struct sample tmp;
3219 int result;
3220
3221 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3222 if (arg_p[0].type != ARGT_VAR)
3223 return 0;
3224 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3225 return 0;
3226 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3227 return 0;
3228
3229 if (smp->data.u.str.data != tmp.data.u.str.data) {
3230 smp->data.u.sint = 0;
3231 smp->data.type = SMP_T_BOOL;
3232 return 1;
3233 }
3234
3235 /* The following comparison is performed in constant time. */
3236 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3237
3238 smp->data.u.sint = result == 0;
3239 smp->data.type = SMP_T_BOOL;
3240 return 1;
3241}
3242#endif
3243
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02003244/* Takes a boolean as input. Returns the first argument if that boolean is true and
3245 * the second argument otherwise.
3246 */
3247static int sample_conv_iif(const struct arg *arg_p, struct sample *smp, void *private)
3248{
3249 smp->data.type = SMP_T_STR;
3250 smp->flags |= SMP_F_CONST;
3251
3252 if (smp->data.u.sint) {
3253 smp->data.u.str.data = arg_p[0].data.str.data;
3254 smp->data.u.str.area = arg_p[0].data.str.area;
3255 }
3256 else {
3257 smp->data.u.str.data = arg_p[1].data.str.data;
3258 smp->data.u.str.area = arg_p[1].data.str.area;
3259 }
3260
3261 return 1;
3262}
3263
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003264#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3265#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3266#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3267
3268/*
3269 * Extract the field value of an input binary sample. Takes a mandatory argument:
3270 * the protocol buffers field identifier (dotted notation) internally represented
3271 * as an array of unsigned integers and its size.
3272 * Return 1 if the field was found, 0 if not.
3273 */
3274static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3275{
3276 unsigned char *pos;
3277 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003278
3279 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003280 grpc_left = smp->data.u.str.data;
3281
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003282 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003283 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003284
3285 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3286
3287 pos += GRPC_MSG_HEADER_SZ;
3288 grpc_left -= GRPC_MSG_HEADER_SZ;
3289
3290 if (grpc_left < left)
3291 return 0;
3292
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003293 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3294 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003295
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003296 grpc_left -= grpc_msg_len;
3297 }
3298
3299 return 0;
3300}
3301
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003302static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3303{
3304 unsigned char *pos;
3305 size_t left;
3306
3307 pos = (unsigned char *)smp->data.u.str.area;
3308 left = smp->data.u.str.data;
3309
3310 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3311}
3312
3313static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3314 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003315{
3316 if (!args[1].type) {
3317 args[1].type = ARGT_SINT;
3318 args[1].data.sint = PBUF_T_BINARY;
3319 }
3320 else {
3321 int pbuf_type;
3322
3323 pbuf_type = protobuf_type(args[1].data.str.area);
3324 if (pbuf_type == -1) {
3325 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3326 return 0;
3327 }
3328
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003329 chunk_destroy(&args[1].data.str);
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003330 args[1].type = ARGT_SINT;
3331 args[1].data.sint = pbuf_type;
3332 }
3333
3334 return 1;
3335}
3336
Tim Duesterhusca097c12018-04-27 21:18:45 +02003337/* This function checks the "strcmp" converter's arguments and extracts the
3338 * variable name and its scope.
3339 */
3340static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3341 const char *file, int line, char **err)
3342{
3343 /* Try to decode a variable. */
3344 if (vars_check_arg(&args[0], NULL))
3345 return 1;
3346
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003347 memprintf(err, "failed to register variable name '%s'",
3348 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003349 return 0;
3350}
3351
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003352#ifdef USE_OPENSSL
3353/* This function checks the "secure_memcmp" converter's arguments and extracts the
3354 * variable name and its scope.
3355 */
3356static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3357 const char *file, int line, char **err)
3358{
3359 /* Try to decode a variable. */
3360 if (vars_check_arg(&args[0], NULL))
3361 return 1;
3362
3363 memprintf(err, "failed to register variable name '%s'",
3364 args[0].data.str.area);
3365 return 0;
3366}
3367#endif
3368
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003369/**/
3370static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3371{
3372 struct buffer *tmp;
3373 uint32_t n;
3374
3375 n = htonl((uint32_t)smp->data.u.sint);
3376 tmp = get_trash_chunk();
3377
3378 memcpy(b_head(tmp), &n, 4);
3379 b_add(tmp, 4);
3380
3381 smp->data.u.str = *tmp;
3382 smp->data.type = SMP_T_BIN;
3383 return 1;
3384}
3385
Christopher Fauletea159d62020-04-01 16:21:44 +02003386/**/
3387static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3388{
3389 char *p;
3390 size_t l;
3391
3392 p = smp->data.u.str.area;
3393 for (l = 0; l < smp->data.u.str.data; l++) {
3394 if (*(p+l) == '\r' || *(p+l) == '\n')
3395 break;
3396 }
3397 smp->data.u.str.data = l;
3398 return 1;
3399}
3400
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003401/**/
3402static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3403{
3404 char *delimiters, *p;
3405 size_t dlen, l;
3406
3407 delimiters = arg_p[0].data.str.area;
3408 dlen = arg_p[0].data.str.data;
3409
3410 l = smp->data.u.str.data;
3411 p = smp->data.u.str.area;
3412 while (l && memchr(delimiters, *p, dlen) != NULL) {
3413 p++;
3414 l--;
3415 }
3416
3417 smp->data.u.str.area = p;
3418 smp->data.u.str.data = l;
3419 return 1;
3420}
3421
Christopher Faulet568415a2020-04-01 17:24:47 +02003422/**/
3423static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3424{
3425 char *delimiters, *p;
3426 size_t dlen, l;
3427
3428 delimiters = arg_p[0].data.str.area;
3429 dlen = arg_p[0].data.str.data;
3430
3431 l = smp->data.u.str.data;
3432 p = smp->data.u.str.area + l - 1;
3433 while (l && memchr(delimiters, *p, dlen) != NULL) {
3434 p--;
3435 l--;
3436 }
3437
3438 smp->data.u.str.data = l;
3439 return 1;
3440}
3441
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003442/************************************************************************/
3443/* All supported sample fetch functions must be declared here */
3444/************************************************************************/
3445
3446/* force TRUE to be returned at the fetch level */
3447static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003448smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003449{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003450 if (!smp_make_rw(smp))
3451 return 0;
3452
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003453 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003454 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003455 return 1;
3456}
3457
3458/* force FALSE to be returned at the fetch level */
3459static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003460smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003461{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003462 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003463 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003464 return 1;
3465}
3466
3467/* retrieve environment variable $1 as a string */
3468static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003469smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003470{
3471 char *env;
3472
3473 if (!args || args[0].type != ARGT_STR)
3474 return 0;
3475
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003476 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003477 if (!env)
3478 return 0;
3479
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003480 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003481 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003482 smp->data.u.str.area = env;
3483 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003484 return 1;
3485}
3486
Damien Claisseae6f1252019-10-30 15:57:28 +00003487/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3488 * optional string representing the unit of the result: "s" for seconds, "ms" for
3489 * milliseconds and "us" for microseconds.
3490 * Returns 0 on error and non-zero if OK.
3491 */
3492int smp_check_date_unit(struct arg *args, char **err)
3493{
3494 if (args[1].type == ARGT_STR) {
Christopher Faulet95917132020-08-05 23:07:07 +02003495 long long int unit;
3496
Damien Claisseae6f1252019-10-30 15:57:28 +00003497 if (strcmp(args[1].data.str.area, "s") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003498 unit = TIME_UNIT_S;
Damien Claisseae6f1252019-10-30 15:57:28 +00003499 }
3500 else if (strcmp(args[1].data.str.area, "ms") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003501 unit = TIME_UNIT_MS;
Damien Claisseae6f1252019-10-30 15:57:28 +00003502 }
3503 else if (strcmp(args[1].data.str.area, "us") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003504 unit = TIME_UNIT_US;
Damien Claisseae6f1252019-10-30 15:57:28 +00003505 }
3506 else {
3507 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3508 args[1].data.str.area);
3509 return 0;
3510 }
Christopher Faulet95917132020-08-05 23:07:07 +02003511
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003512 chunk_destroy(&args[1].data.str);
Damien Claisseae6f1252019-10-30 15:57:28 +00003513 args[1].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02003514 args[1].data.sint = unit;
Damien Claisseae6f1252019-10-30 15:57:28 +00003515 }
3516 else if (args[1].type != ARGT_STOP) {
3517 memprintf(err, "Unexpected arg type");
3518 return 0;
3519 }
3520
3521 return 1;
3522}
3523
3524/* retrieve the current local date in epoch time, converts it to milliseconds
3525 * or microseconds if asked to in optional args[1] unit param, and applies an
3526 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003527 */
3528static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003529smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003530{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003531 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003532
Damien Claisseae6f1252019-10-30 15:57:28 +00003533 /* report in milliseconds */
3534 if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
3535 smp->data.u.sint *= 1000;
3536 smp->data.u.sint += date.tv_usec / 1000;
3537 }
3538 /* report in microseconds */
3539 else if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
3540 smp->data.u.sint *= 1000000;
3541 smp->data.u.sint += date.tv_usec;
3542 }
3543
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003544 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003545 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003546 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003547
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003548 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003549 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3550 return 1;
3551}
3552
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003553/* retrieve the current microsecond part of the date */
3554static int
3555smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3556{
3557 smp->data.u.sint = date.tv_usec;
3558 smp->data.type = SMP_T_SINT;
3559 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3560 return 1;
3561}
3562
3563
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003564/* returns the hostname */
3565static int
3566smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3567{
3568 smp->data.type = SMP_T_STR;
3569 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003570 smp->data.u.str.area = hostname;
3571 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003572 return 1;
3573}
3574
Willy Tarreau0f30d262014-11-24 16:02:05 +01003575/* returns the number of processes */
3576static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003577smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003578{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003579 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003580 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003581 return 1;
3582}
3583
3584/* returns the number of the current process (between 1 and nbproc */
3585static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003586smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003587{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003588 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003589 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003590 return 1;
3591}
3592
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003593/* returns the number of the current thread (between 1 and nbthread */
3594static int
3595smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3596{
3597 smp->data.type = SMP_T_SINT;
3598 smp->data.u.sint = tid;
3599 return 1;
3600}
3601
Willy Tarreau84310e22014-02-14 11:59:04 +01003602/* generate a random 32-bit integer for whatever purpose, with an optional
3603 * range specified in argument.
3604 */
3605static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003606smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003607{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003608 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003609
3610 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003611 if (args && args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003612 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003613
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003614 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003615 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3616 return 1;
3617}
3618
Willy Tarreau0f30d262014-11-24 16:02:05 +01003619/* returns true if the current process is stopping */
3620static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003621smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003622{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003623 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003624 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003625 return 1;
3626}
3627
Willy Tarreau70fe9442018-11-22 16:07:39 +01003628/* returns the number of calls of the current stream's process_stream() */
3629static int
3630smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
3631{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003632 if (!smp->strm)
3633 return 0;
3634
Willy Tarreau70fe9442018-11-22 16:07:39 +01003635 smp->data.type = SMP_T_SINT;
3636 smp->data.u.sint = smp->strm->task->calls;
3637 return 1;
3638}
3639
3640/* returns the average number of nanoseconds spent processing the stream per call */
3641static int
3642smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3643{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003644 if (!smp->strm)
3645 return 0;
3646
Willy Tarreau70fe9442018-11-22 16:07:39 +01003647 smp->data.type = SMP_T_SINT;
3648 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
3649 return 1;
3650}
3651
3652/* returns the total number of nanoseconds spent processing the stream */
3653static int
3654smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3655{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003656 if (!smp->strm)
3657 return 0;
3658
Willy Tarreau70fe9442018-11-22 16:07:39 +01003659 smp->data.type = SMP_T_SINT;
3660 smp->data.u.sint = smp->strm->task->cpu_time;
3661 return 1;
3662}
3663
3664/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
3665static int
3666smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3667{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003668 if (!smp->strm)
3669 return 0;
3670
Willy Tarreau70fe9442018-11-22 16:07:39 +01003671 smp->data.type = SMP_T_SINT;
3672 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
3673 return 1;
3674}
3675
3676/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
3677static int
3678smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3679{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003680 if (!smp->strm)
3681 return 0;
3682
Willy Tarreau70fe9442018-11-22 16:07:39 +01003683 smp->data.type = SMP_T_SINT;
3684 smp->data.u.sint = smp->strm->task->lat_time;
3685 return 1;
3686}
3687
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003688static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
3689{
3690 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003691 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003692 smp->data.u.str.area = args[0].data.str.area;
3693 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003694 return 1;
3695}
3696
3697static int smp_check_const_bool(struct arg *args, char **err)
3698{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003699 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
3700 strcasecmp(args[0].data.str.area, "1") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003701 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003702 args[0].type = ARGT_SINT;
3703 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003704 return 1;
3705 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003706 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
3707 strcasecmp(args[0].data.str.area, "0") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003708 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003709 args[0].type = ARGT_SINT;
3710 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003711 return 1;
3712 }
3713 memprintf(err, "Expects 'true', 'false', '0' or '1'");
3714 return 0;
3715}
3716
3717static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
3718{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003719 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003720 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003721 return 1;
3722}
3723
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003724static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003725{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003726 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003727 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003728 return 1;
3729}
3730
3731static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
3732{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003733 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003734 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003735 return 1;
3736}
3737
3738static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
3739{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003740 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003741 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003742 return 1;
3743}
3744
3745static int smp_check_const_bin(struct arg *args, char **err)
3746{
David Carlier64a16ab2016-04-08 10:37:02 +01003747 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003748 int binstrlen;
3749
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003750 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003751 return 0;
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003752 chunk_destroy(&args[0].data.str);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003753 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003754 args[0].data.str.area = binstr;
3755 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003756 return 1;
3757}
3758
3759static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
3760{
3761 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003762 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003763 smp->data.u.str.area = args[0].data.str.area;
3764 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003765 return 1;
3766}
3767
3768static int smp_check_const_meth(struct arg *args, char **err)
3769{
3770 enum http_meth_t meth;
3771 int i;
3772
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003773 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003774 if (meth != HTTP_METH_OTHER) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003775 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003776 args[0].type = ARGT_SINT;
3777 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003778 } else {
Ilya Shipitsin6b79f382020-07-23 00:32:55 +05003779 /* Check method avalaibility. A method is a token defined as :
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003780 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
3781 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
3782 * token = 1*tchar
3783 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003784 for (i = 0; i < args[0].data.str.data; i++) {
3785 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003786 memprintf(err, "expects valid method.");
3787 return 0;
3788 }
3789 }
3790 }
3791 return 1;
3792}
3793
3794static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
3795{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003796 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003797 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003798 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003799 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003800 smp->data.u.meth.str.area = "";
3801 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003802 } else {
3803 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003804 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003805 smp->data.u.meth.str.area = args[0].data.str.area;
3806 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003807 }
3808 return 1;
3809}
3810
Luca Schimweg8a694b82019-09-10 15:42:52 +02003811// This function checks the "uuid" sample's arguments.
3812// Function won't get called when no parameter is specified (maybe a bug?)
3813static int smp_check_uuid(struct arg *args, char **err)
3814{
3815 if (!args[0].type) {
3816 args[0].type = ARGT_SINT;
3817 args[0].data.sint = 4;
3818 }
3819 else if (args[0].data.sint != 4) {
3820 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
3821 return 0;
3822 }
3823
3824 return 1;
3825}
3826
3827// Generate a RFC4122 UUID (default is v4 = fully random)
3828static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
3829{
3830 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01003831 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02003832 smp->data.type = SMP_T_STR;
3833 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3834 smp->data.u.str = trash;
3835 return 1;
3836 }
3837
3838 // more implementations of other uuid formats possible here
3839 return 0;
3840}
3841
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003842/* Note: must not be declared <const> as its list will be overwritten.
3843 * Note: fetches that may return multiple types must be declared as the lowest
3844 * common denominator, the type that can be casted into all other ones. For
3845 * instance IPv4/IPv6 must be declared IPv4.
3846 */
3847static struct sample_fetch_kw_list smp_kws = {ILH, {
3848 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
3849 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003850 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Damien Claisseae6f1252019-10-30 15:57:28 +00003851 { "date", smp_fetch_date, ARG2(0,SINT,STR), smp_check_date_unit, SMP_T_SINT, SMP_USE_INTRN },
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003852 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003853 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003854 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3855 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003856 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003857 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01003858 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003859 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Luca Schimweg8a694b82019-09-10 15:42:52 +02003860 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003861
3862 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3863 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3864 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3865 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3866 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003867
3868 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
3869 { "bool", smp_fetch_const_bool, ARG1(1,STR), smp_check_const_bool, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003870 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003871 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
3872 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
3873 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
3874 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
3875
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003876 { /* END */ },
3877}};
3878
Willy Tarreau0108d902018-11-25 19:14:37 +01003879INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3880
Emeric Brun107ca302010-01-04 16:16:05 +01003881/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003882static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau0851fd52019-12-17 10:07:25 +01003883 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
Holger Just1bfc24b2017-05-06 00:56:53 +02003884 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02003885 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02003886 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
3887 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01003888 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01003889 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02003890 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01003891 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003892 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
3893 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003894 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01003895 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003896 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3897 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3898 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01003899 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3900 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003901 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003902 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
Marcin Deranek9631a282018-04-16 14:30:46 +02003903 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
3904 { "word", sample_conv_word, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
Willy Tarreau7eda8492015-01-20 19:47:06 +01003905 { "regsub", sample_conv_regsub, ARG3(2,REG,STR,STR), sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02003906 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003907#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01003908 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02003909#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
3910 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
3911#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02003912 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
3913 { "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 +02003914#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01003915 { "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 +02003916 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003917#ifdef USE_OPENSSL
3918 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
3919#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003920
3921 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003922 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
3923 { "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 +01003924
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02003925 { "iif", sample_conv_iif, ARG2(2, STR, STR), NULL, SMP_T_BOOL, SMP_T_STR },
3926
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003927 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3928 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3929 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3930 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
3931 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3932 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3933 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3934 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3935 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3936 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3937 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3938 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3939 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3940 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01003941
Christopher Fauletea159d62020-04-01 16:21:44 +02003942 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
3943 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003944 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02003945 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02003946 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01003947}};
3948
Willy Tarreau0108d902018-11-25 19:14:37 +01003949INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);