blob: bf2de2a2522ddd55fda61b6cc317cd25b5fbc533 [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>
Baptiste Assmanne138dda2020-10-22 15:39:03 +020029#include <haproxy/fix.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020030#include <haproxy/global.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020031#include <haproxy/hash.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020032#include <haproxy/http.h>
Baptiste Assmanne138dda2020-10-22 15:39:03 +020033#include <haproxy/istbuf.h>
Baptiste Assmanne279ca62020-10-27 18:10:06 +010034#include <haproxy/mqtt.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020035#include <haproxy/net_helper.h>
Willy Tarreaub23e5952020-06-04 16:06:59 +020036#include <haproxy/protobuf.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020037#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020038#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020039#include <haproxy/sample.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020040#include <haproxy/sink.h>
41#include <haproxy/stick_table.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020042#include <haproxy/tools.h>
Willy Tarreau8c42b8a2020-06-04 19:27:34 +020043#include <haproxy/uri_auth-t.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020044#include <haproxy/vars.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010045
Willy Tarreau1cf8f082014-02-07 12:14:54 +010046/* sample type names */
47const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020048 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010049 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010050 [SMP_T_SINT] = "sint",
51 [SMP_T_ADDR] = "addr",
52 [SMP_T_IPV4] = "ipv4",
53 [SMP_T_IPV6] = "ipv6",
54 [SMP_T_STR] = "str",
55 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020056 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010057};
58
Willy Tarreau12785782012-04-27 21:37:17 +020059/* static sample used in sample_process() when <p> is NULL */
Emeric Brune5c918b2017-06-14 14:15:36 +020060static THREAD_LOCAL struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010061
Willy Tarreau12785782012-04-27 21:37:17 +020062/* list head of all known sample fetch keywords */
63static struct sample_fetch_kw_list sample_fetches = {
64 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010065};
66
Willy Tarreau12785782012-04-27 21:37:17 +020067/* list head of all known sample format conversion keywords */
68static struct sample_conv_kw_list sample_convs = {
69 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010070};
71
Willy Tarreau80aca902013-01-07 15:42:20 +010072const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
73 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
74 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
75 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
76 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
77 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
78 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010079 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +010080
81 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
82 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
83 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
84 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
85 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
86 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010087 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010088
89 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
90 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
91 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
92 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
93 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
94 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010095 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010096
97 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
98 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
99 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
100 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
101 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
102 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100103 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100104
105 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
106 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
107 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
108 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
109 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
110 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100111 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100112
113 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
114 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
115 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
116 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
117 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
118 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100119 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100120
121 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
122 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
123 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
124 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
125 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
126 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100127 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100128
129 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
130 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
131 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
132 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
133 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
134 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100135 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100136
137 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
138 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
139 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
140 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
141 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
142 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100143 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100144
145 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
146 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
147 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
148 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
149 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
150 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100151 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100152
153 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
154 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
155 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
156 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
157 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
158 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100159 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100160
161 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
162 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
163 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
164 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
165 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
166 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100167 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100168
169 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
170 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
171 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
172 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
173 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
174 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100175 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100176
177 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
178 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
179 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
180 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
181 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
182 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100183 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100184
185 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
186 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
187 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
188 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
189 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
190 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200191 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100192
193 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
194 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
195 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
196 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
197 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
198 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200199 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100200
201 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
202 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
203 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
204 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
205 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
206 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200207 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100208
209 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
210 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
211 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
212 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
213 SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
214 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200215 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100216
217 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
218 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
220 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
221 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
222 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100223 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100224
225 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
226 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
227 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
228 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
229 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
230 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100231 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100232
233 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
234 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
235 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
236 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
237 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
238 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100239 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100240
241 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
242 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
243 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
244 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
245 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
246 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100247 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100248};
249
250static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
251 [SMP_SRC_INTRN] = "internal state",
252 [SMP_SRC_LISTN] = "listener",
253 [SMP_SRC_FTEND] = "frontend",
254 [SMP_SRC_L4CLI] = "client address",
255 [SMP_SRC_L5CLI] = "client-side connection",
256 [SMP_SRC_TRACK] = "track counters",
257 [SMP_SRC_L6REQ] = "request buffer",
258 [SMP_SRC_HRQHV] = "HTTP request headers",
259 [SMP_SRC_HRQHP] = "HTTP request",
260 [SMP_SRC_HRQBO] = "HTTP request body",
261 [SMP_SRC_BKEND] = "backend",
262 [SMP_SRC_SERVR] = "server",
263 [SMP_SRC_L4SRV] = "server address",
264 [SMP_SRC_L5SRV] = "server-side connection",
265 [SMP_SRC_L6RES] = "response buffer",
266 [SMP_SRC_HRSHV] = "HTTP response headers",
267 [SMP_SRC_HRSHP] = "HTTP response",
268 [SMP_SRC_HRSBO] = "HTTP response body",
269 [SMP_SRC_RQFIN] = "request buffer statistics",
270 [SMP_SRC_RSFIN] = "response buffer statistics",
271 [SMP_SRC_TXFIN] = "transaction statistics",
272 [SMP_SRC_SSFIN] = "session statistics",
273};
274
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100275static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
276 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
277 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
278 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
279 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
280 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
281 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
282 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
283 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
284 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
285 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
286 [SMP_CKP_BE_SRV_CON] = "server source selection",
287 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
288 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
289 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
290 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
291 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
292 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
293 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
294 [SMP_CKP_FE_LOG_END] = "logs",
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100295 [SMP_CKP_BE_CHK_RUL] = "backend tcp-check rule",
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100296};
297
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100298/* This function returns the type of the data returned by the sample_expr.
299 * It assumes that the <expr> and all of its converters are properly
300 * initialized.
301 */
302inline
303int smp_expr_output_type(struct sample_expr *expr)
304{
305 struct sample_conv_expr *smp_expr;
306
307 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
308 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
309 return smp_expr->conv->out_type;
310 }
311 return expr->fetch->out_type;
312}
313
314
Willy Tarreau80aca902013-01-07 15:42:20 +0100315/* fill the trash with a comma-delimited list of source names for the <use> bit
316 * field which must be composed of a non-null set of SMP_USE_* flags. The return
317 * value is the pointer to the string in the trash buffer.
318 */
319const char *sample_src_names(unsigned int use)
320{
321 int bit;
322
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200323 trash.data = 0;
324 trash.area[0] = '\0';
Willy Tarreau80aca902013-01-07 15:42:20 +0100325 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
326 if (!(use & ~((1 << bit) - 1)))
327 break; /* no more bits */
328
329 if (!(use & (1 << bit)))
330 continue; /* bit not set */
331
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200332 trash.data += snprintf(trash.area + trash.data,
333 trash.size - trash.data, "%s%s",
334 (use & ((1 << bit) - 1)) ? "," : "",
335 fetch_src_names[bit]);
Willy Tarreau80aca902013-01-07 15:42:20 +0100336 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200337 return trash.area;
Willy Tarreau80aca902013-01-07 15:42:20 +0100338}
339
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100340/* return a pointer to the correct sample checkpoint name, or "unknown" when
341 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
342 * if set.
343 */
344const char *sample_ckp_names(unsigned int use)
345{
346 int bit;
347
348 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
349 if (use & (1 << bit))
350 return fetch_ckp_names[bit];
351 return "unknown sample check place, please report this bug";
352}
353
Emeric Brun107ca302010-01-04 16:16:05 +0100354/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100355 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
356 * for next parsing sessions. The fetch keywords capabilities are also computed
357 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100358 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100359void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100360{
Willy Tarreau80aca902013-01-07 15:42:20 +0100361 struct sample_fetch *sf;
362 int bit;
363
364 for (sf = kwl->kw; sf->kw != NULL; sf++) {
365 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
366 if (sf->use & (1 << bit))
367 sf->val |= fetch_cap[bit];
368 }
369 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100370}
371
372/*
Willy Tarreau12785782012-04-27 21:37:17 +0200373 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100374 * parsing sessions.
375 */
Willy Tarreau12785782012-04-27 21:37:17 +0200376void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100377{
Willy Tarreau12785782012-04-27 21:37:17 +0200378 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100379}
380
381/*
Willy Tarreau12785782012-04-27 21:37:17 +0200382 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100383 * string of <len> in buffer <kw>.
384 *
385 */
Willy Tarreau12785782012-04-27 21:37:17 +0200386struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100387{
388 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200389 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100390
Willy Tarreau12785782012-04-27 21:37:17 +0200391 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100392 for (index = 0; kwl->kw[index].kw != NULL; index++) {
393 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
394 kwl->kw[index].kw[len] == '\0')
395 return &kwl->kw[index];
396 }
397 }
398 return NULL;
399}
400
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100401/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100402 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100403 * <idx> is the index of the next sample fetch entry. It is used as private
404 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100405 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100406 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100407 * the list is reached.
408 */
409struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
410{
411 struct sample_fetch_kw_list *kwl;
412 struct sample_fetch *base;
413
414 if (!current) {
415 /* Get first kwl entry. */
416 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
417 (*idx) = 0;
418 } else {
419 /* Get kwl corresponding to the curret entry. */
420 base = current + 1 - (*idx);
421 kwl = container_of(base, struct sample_fetch_kw_list, kw);
422 }
423
424 while (1) {
425
426 /* Check if kwl is the last entry. */
427 if (&kwl->list == &sample_fetches.list)
428 return NULL;
429
430 /* idx contain the next keyword. If it is available, return it. */
431 if (kwl->kw[*idx].kw) {
432 (*idx)++;
433 return &kwl->kw[(*idx)-1];
434 }
435
436 /* get next entry in the main list, and return NULL if the end is reached. */
437 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
438
439 /* Set index to 0, ans do one other loop. */
440 (*idx) = 0;
441 }
442}
443
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100444/* This function browses the list of available converters. <current> is
445 * the last used converter. If it is the first call, it must set to NULL.
446 * <idx> is the index of the next converter entry. It is used as private
447 * value. It is useless to initiate it.
448 *
449 * It returns always the next sample_conv entry, and NULL when the end of
450 * the list is reached.
451 */
452struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
453{
454 struct sample_conv_kw_list *kwl;
455 struct sample_conv *base;
456
457 if (!current) {
458 /* Get first kwl entry. */
459 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
460 (*idx) = 0;
461 } else {
462 /* Get kwl corresponding to the curret entry. */
463 base = current + 1 - (*idx);
464 kwl = container_of(base, struct sample_conv_kw_list, kw);
465 }
466
467 while (1) {
468 /* Check if kwl is the last entry. */
469 if (&kwl->list == &sample_convs.list)
470 return NULL;
471
472 /* idx contain the next keyword. If it is available, return it. */
473 if (kwl->kw[*idx].kw) {
474 (*idx)++;
475 return &kwl->kw[(*idx)-1];
476 }
477
478 /* get next entry in the main list, and return NULL if the end is reached. */
479 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
480
481 /* Set index to 0, ans do one other loop. */
482 (*idx) = 0;
483 }
484}
485
Emeric Brun107ca302010-01-04 16:16:05 +0100486/*
Willy Tarreau12785782012-04-27 21:37:17 +0200487 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100488 * string of <len> in buffer <kw>.
489 *
490 */
Willy Tarreau12785782012-04-27 21:37:17 +0200491struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100492{
493 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200494 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100495
Willy Tarreau12785782012-04-27 21:37:17 +0200496 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100497 for (index = 0; kwl->kw[index].kw != NULL; index++) {
498 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
499 kwl->kw[index].kw[len] == '\0')
500 return &kwl->kw[index];
501 }
502 }
503 return NULL;
504}
505
Emeric Brun107ca302010-01-04 16:16:05 +0100506/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200507/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100508/******************************************************************/
509
Willy Tarreau342acb42012-04-23 22:03:39 +0200510static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100511{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200512 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200513 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100514 return 1;
515}
516
Willy Tarreau342acb42012-04-23 22:03:39 +0200517static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100518{
Willy Tarreau83061a82018-07-13 11:56:34 +0200519 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100520
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200521 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100522 return 0;
523
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200524 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200525 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200526 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100527 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100528
529 return 1;
530}
531
Willy Tarreau342acb42012-04-23 22:03:39 +0200532static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100533{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200534 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200535 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100536 return 1;
537}
538
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200539static int c_ipv62ip(struct sample *smp)
540{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200541 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200542 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100543 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200544 return 1;
545}
546
Willy Tarreau342acb42012-04-23 22:03:39 +0200547static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100548{
Willy Tarreau83061a82018-07-13 11:56:34 +0200549 struct buffer *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100550
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200551 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100552 return 0;
553
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200554 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200555 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200556 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100557 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100558 return 1;
559}
560
561/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200562static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100563{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200564 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100565}
566*/
567
Willy Tarreau342acb42012-04-23 22:03:39 +0200568static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100569{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200570 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200571 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100572 return 1;
573}
574
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200575static int c_int2ipv6(struct sample *smp)
576{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200577 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
578 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200579 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200580 return 1;
581}
582
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100583static int c_str2addr(struct sample *smp)
584{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200585 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4)) {
586 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100587 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200588 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100589 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100590 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100591 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200592 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100593 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100594 return 1;
595}
596
Willy Tarreau342acb42012-04-23 22:03:39 +0200597static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100598{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200599 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100600 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200601 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100602 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100603 return 1;
604}
605
Willy Tarreau342acb42012-04-23 22:03:39 +0200606static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100607{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200608 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100609 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200610 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100611 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100612 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100613}
614
Emeric Brun4b9e8022014-11-03 18:17:10 +0100615/*
616 * The NULL char always enforces the end of string if it is met.
617 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100618 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200619static int c_bin2str(struct sample *smp)
620{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100621 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200622
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200623 for (i = 0; i < smp->data.u.str.data; i++) {
624 if (!smp->data.u.str.area[i]) {
625 smp->data.u.str.data = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100626 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100627 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200628 }
Christopher Faulet472ad512020-04-30 09:57:40 +0200629 smp->data.type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200630 return 1;
631}
632
Willy Tarreau342acb42012-04-23 22:03:39 +0200633static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100634{
Willy Tarreau83061a82018-07-13 11:56:34 +0200635 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100636 char *pos;
637
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200638 pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100639 if (!pos)
640 return 0;
641
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200642 trash->size = trash->size - (pos - trash->area);
643 trash->area = pos;
644 trash->data = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200645 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200646 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100647 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100648 return 1;
649}
650
Joseph Herlant757f5ad2018-11-15 12:14:56 -0800651/* This function unconditionally duplicates data and removes the "const" flag.
Willy Tarreauad635822016-08-08 19:21:09 +0200652 * For strings and binary blocks, it also provides a known allocated size with
653 * a length that is capped to the size, and ensures a trailing zero is always
654 * appended for strings. This is necessary for some operations which may
655 * require to extend the length. It returns 0 if it fails, 1 on success.
656 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100657int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200658{
Willy Tarreau83061a82018-07-13 11:56:34 +0200659 struct buffer *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200660
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200661 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100662 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100663 case SMP_T_SINT:
664 case SMP_T_ADDR:
665 case SMP_T_IPV4:
666 case SMP_T_IPV6:
667 /* These type are not const. */
668 break;
Willy Tarreauad635822016-08-08 19:21:09 +0200669
Christopher Fauletec100512017-07-24 15:38:41 +0200670 case SMP_T_METH:
671 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
672 break;
673 /* Fall through */
674
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100675 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200676 trash = get_trash_chunk();
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100677 trash->data = smp->data.type == SMP_T_STR ?
678 smp->data.u.str.data : smp->data.u.meth.str.data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200679 if (trash->data > trash->size - 1)
680 trash->data = trash->size - 1;
Willy Tarreauad635822016-08-08 19:21:09 +0200681
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100682 memcpy(trash->area, smp->data.type == SMP_T_STR ?
683 smp->data.u.str.area : smp->data.u.meth.str.area,
684 trash->data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200685 trash->area[trash->data] = 0;
Willy Tarreauad635822016-08-08 19:21:09 +0200686 smp->data.u.str = *trash;
687 break;
688
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100689 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100690 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200691 trash->data = smp->data.u.str.data;
692 if (trash->data > trash->size)
693 trash->data = trash->size;
Willy Tarreauad635822016-08-08 19:21:09 +0200694
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200695 memcpy(trash->area, smp->data.u.str.area, trash->data);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200696 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100697 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200698
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100699 default:
700 /* Other cases are unexpected. */
701 return 0;
702 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100703
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100704 /* remove const flag */
705 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200706 return 1;
707}
708
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100709int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100710{
711 return 1;
712}
713
Willy Tarreau342acb42012-04-23 22:03:39 +0200714static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100715{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200716 const char *str;
717 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100718
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200719 if (smp->data.u.str.data == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100720 return 0;
721
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200722 str = smp->data.u.str.area;
723 end = smp->data.u.str.area + smp->data.u.str.data;
Emeric Brun107ca302010-01-04 16:16:05 +0100724
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200725 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200726 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100727 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100728 return 1;
729}
730
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100731static int c_str2meth(struct sample *smp)
732{
733 enum http_meth_t meth;
734 int len;
735
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200736 meth = find_http_meth(smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100737 if (meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200738 len = smp->data.u.str.data;
739 smp->data.u.meth.str.area = smp->data.u.str.area;
740 smp->data.u.meth.str.data = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100741 }
742 else
743 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200744 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200745 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100746 return 1;
747}
748
749static int c_meth2str(struct sample *smp)
750{
751 int len;
752 enum http_meth_t meth;
753
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200754 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100755 /* The method is unknown. Copy the original pointer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200756 len = smp->data.u.meth.str.data;
757 smp->data.u.str.area = smp->data.u.meth.str.area;
758 smp->data.u.str.data = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200759 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100760 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200761 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100762 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200763 meth = smp->data.u.meth.meth;
Willy Tarreau35b51c62018-09-10 15:38:55 +0200764 smp->data.u.str.area = http_known_methods[meth].ptr;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200765 smp->data.u.str.data = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100766 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200767 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100768 }
769 else {
770 /* Unknown method */
771 return 0;
772 }
773 return 1;
774}
775
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200776static int c_addr2bin(struct sample *smp)
777{
Willy Tarreau83061a82018-07-13 11:56:34 +0200778 struct buffer *chk = get_trash_chunk();
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200779
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200780 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200781 chk->data = 4;
782 memcpy(chk->area, &smp->data.u.ipv4, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200783 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200784 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200785 chk->data = 16;
786 memcpy(chk->area, &smp->data.u.ipv6, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200787 }
788 else
789 return 0;
790
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200791 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200792 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200793 return 1;
794}
795
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200796static int c_int2bin(struct sample *smp)
797{
Willy Tarreau83061a82018-07-13 11:56:34 +0200798 struct buffer *chk = get_trash_chunk();
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200799
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200800 *(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
801 chk->data = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200802
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200803 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200804 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200805 return 1;
806}
807
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200808
Emeric Brun107ca302010-01-04 16:16:05 +0100809/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200810/* Sample casts matrix: */
811/* sample_casts[from type][to type] */
812/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100813/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100814
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100815sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200816/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
817/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
818/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200819/* 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 +0200820/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
821/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200822/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200823/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
824/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
825/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200826};
Emeric Brun107ca302010-01-04 16:16:05 +0100827
Emeric Brun107ca302010-01-04 16:16:05 +0100828/*
Willy Tarreau12785782012-04-27 21:37:17 +0200829 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100830 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200831 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200832 * The caller must have set al->ctx.
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100833 * If <endptr> is non-nul, it will be set to the first unparsed character
834 * (which may be the final '\0') on success. If it is nul, the expression
835 * must be properly terminated by a '\0' otherwise an error is reported.
Emeric Brun107ca302010-01-04 16:16:05 +0100836 */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100837struct 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 +0100838{
Willy Tarreau833cc792013-07-24 15:34:19 +0200839 const char *begw; /* beginning of word */
840 const char *endw; /* end of word */
841 const char *endt; /* end of term */
Remi Tricot-Le Breton22e0d9b2021-01-12 14:55:12 +0100842 struct sample_expr *expr = NULL;
Willy Tarreau12785782012-04-27 21:37:17 +0200843 struct sample_fetch *fetch;
844 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100845 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200846 char *fkw = NULL;
847 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100848 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100849
Willy Tarreau833cc792013-07-24 15:34:19 +0200850 begw = str[*idx];
Willy Tarreaued2c6622020-02-14 18:27:10 +0100851 for (endw = begw; is_idchar(*endw); endw++)
852 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200853
854 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100855 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100856 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200857 }
Emeric Brun107ca302010-01-04 16:16:05 +0100858
Willy Tarreau833cc792013-07-24 15:34:19 +0200859 /* keep a copy of the current fetch keyword for error reporting */
860 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100861
Willy Tarreau833cc792013-07-24 15:34:19 +0200862 fetch = find_sample_fetch(begw, endw - begw);
863 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100864 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100865 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200866 }
Emeric Brun107ca302010-01-04 16:16:05 +0100867
Willy Tarreau833cc792013-07-24 15:34:19 +0200868 /* At this point, we have :
869 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100870 * - endw : end of the keyword, first character not part of keyword
Willy Tarreau833cc792013-07-24 15:34:19 +0200871 */
872
873 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100874 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100875 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200876 }
Emeric Brun107ca302010-01-04 16:16:05 +0100877 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200878
Vincent Bernat02779b62016-04-03 13:48:43 +0200879 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200880 if (!expr)
881 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100882
883 LIST_INIT(&(expr->conv_exprs));
884 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200885 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100886
Willy Tarreau689a1df2013-12-13 00:40:11 +0100887 /* Note that we call the argument parser even with an empty string,
888 * this allows it to automatically create entries for mandatory
889 * implicit arguments (eg: local proxy name).
890 */
891 al->kw = expr->fetch->kw;
892 al->conv = NULL;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100893 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 +0100894 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
895 goto out_error;
896 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200897
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100898 /* now endt is our first char not part of the arg list, typically the
899 * comma after the sample fetch name or after the closing parenthesis,
900 * or the NUL char.
901 */
902
Willy Tarreau689a1df2013-12-13 00:40:11 +0100903 if (!expr->arg_p) {
904 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200905 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100906 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
907 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200908 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100909 }
910
Willy Tarreau833cc792013-07-24 15:34:19 +0200911 /* Now process the converters if any. We have two supported syntaxes
912 * for the converters, which can be combined :
913 * - comma-delimited list of converters just after the keyword and args ;
914 * - one converter per keyword
915 * The combination allows to have each keyword being a comma-delimited
916 * series of converters.
917 *
918 * We want to process the former first, then the latter. For this we start
919 * from the beginning of the supposed place in the exiting conv chain, which
920 * starts at the last comma (endt).
921 */
922
923 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200924 struct sample_conv_expr *conv_expr;
Willy Tarreau46dfd782019-12-17 10:25:29 +0100925 int err_arg;
926 int argcnt;
Emeric Brun107ca302010-01-04 16:16:05 +0100927
Willy Tarreau833cc792013-07-24 15:34:19 +0200928 if (*endt && *endt != ',') {
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100929 if (endptr) {
930 /* end found, let's stop here */
931 break;
932 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200933 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100934 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200935 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100936 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100937 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200938 }
Emeric Brun107ca302010-01-04 16:16:05 +0100939
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100940 /* FIXME: how long should we support such idiocies ? Maybe we
941 * should already warn ?
942 */
Willy Tarreau833cc792013-07-24 15:34:19 +0200943 while (*endt == ',') /* then trailing commas */
944 endt++;
945
Willy Tarreau97108e02016-11-25 07:33:24 +0100946 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200947
948 if (!*begw) {
949 /* none ? skip to next string */
950 (*idx)++;
951 begw = str[*idx];
952 if (!begw || !*begw)
953 break;
954 }
955
Willy Tarreaued2c6622020-02-14 18:27:10 +0100956 for (endw = begw; is_idchar(*endw); endw++)
957 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200958
959 free(ckw);
960 ckw = my_strndup(begw, endw - begw);
961
962 conv = find_sample_conv(begw, endw - begw);
963 if (!conv) {
964 /* we found an isolated keyword that we don't know, it's not ours */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100965 if (begw == str[*idx]) {
966 endt = begw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200967 break;
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100968 }
Willy Tarreau97108e02016-11-25 07:33:24 +0100969 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200970 goto out_error;
971 }
Emeric Brun107ca302010-01-04 16:16:05 +0100972
Willy Tarreau833cc792013-07-24 15:34:19 +0200973 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100974 memprintf(err_msg, "returns type of converter '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100975 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200976 }
Emeric Brun107ca302010-01-04 16:16:05 +0100977
978 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200979 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100980 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100981 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200982 }
Emeric Brun107ca302010-01-04 16:16:05 +0100983
984 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +0200985 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200986 if (!conv_expr)
987 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100988
989 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
990 conv_expr->conv = conv;
991
Willy Tarreau46dfd782019-12-17 10:25:29 +0100992 al->kw = expr->fetch->kw;
993 al->conv = conv_expr->conv->kw;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100994 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 +0100995 if (argcnt < 0) {
996 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
997 goto out_error;
998 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100999
Willy Tarreau46dfd782019-12-17 10:25:29 +01001000 if (argcnt && !conv->arg_mask) {
1001 memprintf(err_msg, "converter '%s' does not support any args", ckw);
1002 goto out_error;
1003 }
Willy Tarreau21d68a62012-04-20 15:52:36 +02001004
Willy Tarreau46dfd782019-12-17 10:25:29 +01001005 if (!conv_expr->arg_p)
1006 conv_expr->arg_p = empty_arg_list;
Willy Tarreau2e845be2012-10-19 19:49:09 +02001007
Willy Tarreau46dfd782019-12-17 10:25:29 +01001008 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
1009 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001010 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001011 }
1012 }
Emeric Brun485479d2010-09-23 18:02:19 +02001013
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001014 if (endptr) {
1015 /* end found, let's stop here */
1016 *endptr = (char *)endt;
1017 }
1018
Willy Tarreau833cc792013-07-24 15:34:19 +02001019 out:
1020 free(fkw);
1021 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001022 return expr;
1023
1024out_error:
Remi Tricot-Le Breton22e0d9b2021-01-12 14:55:12 +01001025 release_sample_expr(expr);
Willy Tarreau833cc792013-07-24 15:34:19 +02001026 expr = NULL;
1027 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001028}
1029
1030/*
Willy Tarreau12785782012-04-27 21:37:17 +02001031 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001032 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001033 * Returns a pointer on a typed sample structure containing the result or NULL if
1034 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001035 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001036 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001037 *
1038 * Note: the fetch functions are required to properly set the return type. The
1039 * conversion functions must do so too. However the cast functions do not need
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001040 * to since they're made to cast multiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001041 *
1042 * The caller may indicate in <opt> if it considers the result final or not.
1043 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1044 * if the result is stable or not, according to the following table :
1045 *
1046 * return MAY_CHANGE FINAL Meaning for the sample
1047 * NULL 0 * Not present and will never be (eg: header)
1048 * NULL 1 0 Not present yet, could change (eg: POST param)
1049 * NULL 1 1 Not present yet, will not change anymore
1050 * smp 0 * Present and will not change (eg: header)
1051 * smp 1 0 Present, may change (eg: request length)
1052 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001053 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001054struct sample *sample_process(struct proxy *px, struct session *sess,
1055 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001056 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001057{
Willy Tarreau12785782012-04-27 21:37:17 +02001058 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001059
Willy Tarreau18387e22013-07-25 12:02:38 +02001060 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001061 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001062 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001063 }
Emeric Brun107ca302010-01-04 16:16:05 +01001064
Willy Tarreau1777ea62016-03-10 16:15:46 +01001065 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001066 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001067 return NULL;
1068
Emeric Brun107ca302010-01-04 16:16:05 +01001069 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001070 /* we want to ensure that p->type can be casted into
1071 * conv_expr->conv->in_type. We have 3 possibilities :
1072 * - NULL => not castable.
1073 * - c_none => nothing to do (let's optimize it)
1074 * - other => apply cast and prepare to fail
1075 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001076 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001077 return NULL;
1078
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001079 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1080 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001081 return NULL;
1082
Willy Tarreau12e50112012-04-25 17:21:49 +02001083 /* OK cast succeeded */
1084
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001085 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001086 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001087 }
1088 return p;
1089}
1090
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001091/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001092 * Resolve all remaining arguments in proxy <p>. Returns the number of
1093 * errors or 0 if everything is fine.
1094 */
1095int smp_resolve_args(struct proxy *p)
1096{
1097 struct arg_list *cur, *bak;
1098 const char *ctx, *where;
1099 const char *conv_ctx, *conv_pre, *conv_pos;
1100 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001101 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001102 struct arg *arg;
1103 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001104 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001105
1106 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1107 struct proxy *px;
1108 struct server *srv;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001109 struct stktable *t;
1110 char *pname, *sname, *stktname;
Willy Tarreau46947782015-01-19 19:00:58 +01001111 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001112
1113 arg = cur->arg;
1114
1115 /* prepare output messages */
1116 conv_pre = conv_pos = conv_ctx = "";
1117 if (cur->conv) {
1118 conv_ctx = cur->conv;
1119 conv_pre = "conversion keyword '";
1120 conv_pos = "' for ";
1121 }
1122
1123 where = "in";
1124 ctx = "sample fetch keyword";
1125 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001126 case ARGC_STK: where = "in stick rule in"; break;
1127 case ARGC_TRK: where = "in tracking rule in"; break;
1128 case ARGC_LOG: where = "in log-format string in"; break;
1129 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1130 case ARGC_HRQ: where = "in http-request header format string in"; break;
1131 case ARGC_HRS: where = "in http-response header format string in"; break;
1132 case ARGC_UIF: where = "in unique-id-format string in"; break;
1133 case ARGC_RDR: where = "in redirect format string in"; break;
1134 case ARGC_CAP: where = "in capture rule in"; break;
1135 case ARGC_ACL: ctx = "ACL keyword"; break;
1136 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001137 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Christopher Faulet3b967c12020-05-15 15:47:44 +02001138 case ARGC_HERR: where = "in http-error directive in"; break;
Miroslav Zagorac7f8314c2020-12-09 16:31:48 +01001139 case ARGC_OT: where = "in ot-scope directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001140 }
1141
1142 /* set a few default settings */
1143 px = p;
1144 pname = p->id;
1145
1146 switch (arg->type) {
1147 case ARGT_SRV:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001148 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001149 ha_alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1150 cur->file, cur->line,
1151 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001152 cfgerr++;
1153 continue;
1154 }
1155
1156 /* we support two formats : "bck/srv" and "srv" */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001157 sname = strrchr(arg->data.str.area, '/');
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001158
1159 if (sname) {
1160 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001161 pname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001162
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001163 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001164 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001165 ha_alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1166 cur->file, cur->line, pname,
1167 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001168 cfgerr++;
1169 break;
1170 }
1171 }
1172 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001173 sname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001174
1175 srv = findserver(px, sname);
1176 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001177 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",
1178 cur->file, cur->line, sname, pname,
1179 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001180 cfgerr++;
1181 break;
1182 }
1183
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001184 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001185 arg->unresolved = 0;
1186 arg->data.srv = srv;
1187 break;
1188
1189 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001190 if (arg->data.str.data) {
1191 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001192 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001193 }
1194
1195 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001196 ha_alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1197 cur->file, cur->line, pname,
1198 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001199 cfgerr++;
1200 break;
1201 }
1202
1203 if (!(px->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001204 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",
1205 cur->file, cur->line, pname,
1206 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001207 cfgerr++;
1208 break;
1209 }
1210
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001211 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001212 arg->unresolved = 0;
1213 arg->data.prx = px;
1214 break;
1215
1216 case ARGT_BE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001217 if (arg->data.str.data) {
1218 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001219 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001220 }
1221
1222 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001223 ha_alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1224 cur->file, cur->line, pname,
1225 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001226 cfgerr++;
1227 break;
1228 }
1229
1230 if (!(px->cap & PR_CAP_BE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001231 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",
1232 cur->file, cur->line, pname,
1233 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001234 cfgerr++;
1235 break;
1236 }
1237
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001238 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001239 arg->unresolved = 0;
1240 arg->data.prx = px;
1241 break;
1242
1243 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001244 if (arg->data.str.data)
1245 stktname = arg->data.str.area;
1246 else
1247 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001248
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001249 t = stktable_find_by_name(stktname);
1250 if (!t) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001251 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 +01001252 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001253 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001254 cfgerr++;
1255 break;
1256 }
1257
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001258 if (!t->size) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001259 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 +01001260 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001261 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001262 cfgerr++;
1263 break;
1264 }
1265
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001266 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001267 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 +01001268 cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001269 cfgerr++;
1270 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001271 }
1272
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001273 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001274 p->next_stkt_ref = t->proxies_list;
1275 t->proxies_list = p;
1276 }
1277
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001278 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001279 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001280 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001281 break;
1282
1283 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001284 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001285 ha_alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1286 cur->file, cur->line,
1287 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001288 cfgerr++;
1289 break;
1290 }
1291
1292 if (p->uri_auth && p->uri_auth->userlist &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001293 strcmp(p->uri_auth->userlist->name, arg->data.str.area) == 0)
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001294 ul = p->uri_auth->userlist;
1295 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001296 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001297
1298 if (!ul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001299 ha_alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001300 cur->file, cur->line,
1301 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001302 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001303 cfgerr++;
1304 break;
1305 }
1306
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001307 chunk_destroy(&arg->data.str);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001308 arg->unresolved = 0;
1309 arg->data.usr = ul;
1310 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001311
1312 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001313 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001314 ha_alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1315 cur->file, cur->line,
1316 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001317 cfgerr++;
1318 continue;
1319 }
1320
Willy Tarreau46947782015-01-19 19:00:58 +01001321 rflags = 0;
1322 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1323 err = NULL;
1324
Dragan Dosen26743032019-04-30 15:54:36 +02001325 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001326 ha_alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1327 cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001328 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001329 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
Willy Tarreau46947782015-01-19 19:00:58 +01001330 cfgerr++;
1331 continue;
1332 }
1333
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001334 chunk_destroy(&arg->data.str);
Willy Tarreau46947782015-01-19 19:00:58 +01001335 arg->unresolved = 0;
1336 arg->data.reg = reg;
1337 break;
1338
1339
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001340 }
1341
1342 LIST_DEL(&cur->list);
1343 free(cur);
1344 } /* end of args processing */
1345
1346 return cfgerr;
1347}
1348
1349/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001350 * Process a fetch + format conversion as defined by the sample expression
1351 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001352 * not explicitly set to <smp_type>, but shall be compatible with it as
1353 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1354 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001355 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1356 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1357 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1358 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001359 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1360 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1361 * still hope to get it after waiting longer, and is not converted to string.
1362 * The possible output combinations are the following :
1363 *
1364 * return MAY_CHANGE FINAL Meaning for the sample
1365 * NULL * * Not present and will never be (eg: header)
1366 * smp 0 * Final value converted (eg: header)
1367 * smp 1 0 Not present yet, may appear later (eg: header)
1368 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001369 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001370struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001371 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001372 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001373{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001374 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001375
Willy Tarreau6c616e02014-06-25 16:56:41 +02001376 memset(smp, 0, sizeof(*smp));
1377
Willy Tarreau192252e2015-04-04 01:47:55 +02001378 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001379 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1380 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001381 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001382 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001383
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001384 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001385 return NULL;
1386
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001387 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001388 return NULL;
1389
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001390 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001391 return smp;
1392}
1393
Christopher Faulet476e5d02016-10-26 11:34:47 +02001394static void release_sample_arg(struct arg *p)
1395{
1396 struct arg *p_back = p;
1397
1398 if (!p)
1399 return;
1400
1401 while (p->type != ARGT_STOP) {
1402 if (p->type == ARGT_STR || p->unresolved) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001403 chunk_destroy(&p->data.str);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001404 p->unresolved = 0;
1405 }
1406 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001407 regex_free(p->data.reg);
1408 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001409 }
1410 p++;
1411 }
1412
1413 if (p_back != empty_arg_list)
1414 free(p_back);
1415}
1416
1417void release_sample_expr(struct sample_expr *expr)
1418{
1419 struct sample_conv_expr *conv_expr, *conv_exprb;
1420
1421 if (!expr)
1422 return;
1423
Tim Duesterhus867cd982020-07-04 11:49:39 +02001424 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list) {
1425 LIST_DEL(&conv_expr->list);
Christopher Faulet476e5d02016-10-26 11:34:47 +02001426 release_sample_arg(conv_expr->arg_p);
Tim Duesterhus867cd982020-07-04 11:49:39 +02001427 free(conv_expr);
1428 }
1429
Christopher Faulet476e5d02016-10-26 11:34:47 +02001430 release_sample_arg(expr->arg_p);
1431 free(expr);
1432}
1433
Emeric Brun107ca302010-01-04 16:16:05 +01001434/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001435/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001436/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001437/*****************************************************************/
1438
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001439static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1440{
1441 int i;
1442 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001443 struct buffer *buf;
1444 struct sink *sink;
1445 struct ist line;
1446 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001447
Willy Tarreau0851fd52019-12-17 10:07:25 +01001448 buf = alloc_trash_chunk();
1449 if (!buf)
1450 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001451
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001452 sink = (struct sink *)arg_p[1].data.ptr;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001453 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001454
Willy Tarreau0851fd52019-12-17 10:07:25 +01001455 pfx = arg_p[0].data.str.area;
1456 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001457
Willy Tarreau0851fd52019-12-17 10:07:25 +01001458 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1459 if (!sample_casts[smp->data.type][SMP_T_STR])
1460 goto nocast;
1461
1462 /* Copy sample fetch. This puts the sample as const, the
1463 * cast will copy data if a transformation is required.
1464 */
1465 memcpy(&tmp, smp, sizeof(struct sample));
1466 tmp.flags = SMP_F_CONST;
1467
1468 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1469 goto nocast;
1470
1471 /* Display the displayable chars*. */
1472 b_putchr(buf, '<');
1473 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001474 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001475 b_putchr(buf, tmp.data.u.str.area[i]);
1476 else
1477 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001478 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001479 b_putchr(buf, '>');
1480
1481 done:
1482 line = ist2(buf->area, buf->data);
Emeric Brun54648852020-07-06 15:54:06 +02001483 sink_write(sink, &line, 1, 0, 0, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001484 end:
1485 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001486 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001487 nocast:
1488 chunk_appendf(buf, "(undisplayable)");
1489 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001490}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001491
1492// This function checks the "debug" converter's arguments.
1493static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1494 const char *file, int line, char **err)
1495{
1496 const char *name = "buf0";
1497 struct sink *sink = NULL;
1498
1499 if (args[0].type != ARGT_STR) {
1500 /* optional prefix */
1501 args[0].data.str.area = "";
1502 args[0].data.str.data = 0;
1503 }
1504
1505 if (args[1].type == ARGT_STR)
1506 name = args[1].data.str.area;
1507
1508 sink = sink_find(name);
1509 if (!sink) {
1510 memprintf(err, "No such sink '%s'", name);
1511 return 0;
1512 }
1513
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001514 chunk_destroy(&args[1].data.str);
Christopher Fauletb45bf8e2020-08-07 14:00:23 +02001515 args[1].type = ARGT_PTR;
1516 args[1].data.ptr = sink;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001517 return 1;
1518}
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001519
Holger Just1bfc24b2017-05-06 00:56:53 +02001520static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
1521{
Willy Tarreau83061a82018-07-13 11:56:34 +02001522 struct buffer *trash = get_trash_chunk();
Holger Just1bfc24b2017-05-06 00:56:53 +02001523 int bin_len;
1524
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001525 trash->data = 0;
1526 bin_len = base64dec(smp->data.u.str.area, smp->data.u.str.data,
1527 trash->area, trash->size);
Holger Just1bfc24b2017-05-06 00:56:53 +02001528 if (bin_len < 0)
1529 return 0;
1530
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001531 trash->data = bin_len;
Holger Just1bfc24b2017-05-06 00:56:53 +02001532 smp->data.u.str = *trash;
1533 smp->data.type = SMP_T_BIN;
1534 smp->flags &= ~SMP_F_CONST;
1535 return 1;
1536}
1537
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001538static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun53d1a982014-04-30 18:21:37 +02001539{
Willy Tarreau83061a82018-07-13 11:56:34 +02001540 struct buffer *trash = get_trash_chunk();
Emeric Brun53d1a982014-04-30 18:21:37 +02001541 int b64_len;
1542
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001543 trash->data = 0;
1544 b64_len = a2base64(smp->data.u.str.area, smp->data.u.str.data,
1545 trash->area, trash->size);
Emeric Brun53d1a982014-04-30 18:21:37 +02001546 if (b64_len < 0)
1547 return 0;
1548
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001549 trash->data = b64_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001550 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001551 smp->data.type = SMP_T_STR;
Emeric Brun53d1a982014-04-30 18:21:37 +02001552 smp->flags &= ~SMP_F_CONST;
1553 return 1;
1554}
1555
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001556static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
1557{
1558 blk_SHA_CTX ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001559 struct buffer *trash = get_trash_chunk();
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001560
1561 memset(&ctx, 0, sizeof(ctx));
1562
1563 blk_SHA1_Init(&ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001564 blk_SHA1_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1565 blk_SHA1_Final((unsigned char *) trash->area, &ctx);
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001566
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001567 trash->data = 20;
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +02001568 smp->data.u.str = *trash;
1569 smp->data.type = SMP_T_BIN;
1570 smp->flags &= ~SMP_F_CONST;
1571 return 1;
1572}
1573
Tim Duesterhusd4376302019-06-17 12:41:44 +02001574#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01001575static int smp_check_sha2(struct arg *args, struct sample_conv *conv,
1576 const char *file, int line, char **err)
1577{
1578 if (args[0].type == ARGT_STOP)
1579 return 1;
1580 if (args[0].type != ARGT_SINT) {
1581 memprintf(err, "Invalid type '%s'", arg_type_names[args[0].type]);
1582 return 0;
1583 }
1584
1585 switch (args[0].data.sint) {
1586 case 224:
1587 case 256:
1588 case 384:
1589 case 512:
1590 /* this is okay */
1591 return 1;
1592 default:
1593 memprintf(err, "Unsupported number of bits: '%lld'", args[0].data.sint);
1594 return 0;
1595 }
1596}
1597
Tim Duesterhusd4376302019-06-17 12:41:44 +02001598static int sample_conv_sha2(const struct arg *arg_p, struct sample *smp, void *private)
1599{
1600 struct buffer *trash = get_trash_chunk();
1601 int bits = 256;
1602 if (arg_p && arg_p->data.sint)
1603 bits = arg_p->data.sint;
1604
1605 switch (bits) {
1606 case 224: {
1607 SHA256_CTX ctx;
1608
1609 memset(&ctx, 0, sizeof(ctx));
1610
1611 SHA224_Init(&ctx);
1612 SHA224_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1613 SHA224_Final((unsigned char *) trash->area, &ctx);
1614 trash->data = SHA224_DIGEST_LENGTH;
1615 break;
1616 }
1617 case 256: {
1618 SHA256_CTX ctx;
1619
1620 memset(&ctx, 0, sizeof(ctx));
1621
1622 SHA256_Init(&ctx);
1623 SHA256_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1624 SHA256_Final((unsigned char *) trash->area, &ctx);
1625 trash->data = SHA256_DIGEST_LENGTH;
1626 break;
1627 }
1628 case 384: {
1629 SHA512_CTX ctx;
1630
1631 memset(&ctx, 0, sizeof(ctx));
1632
1633 SHA384_Init(&ctx);
1634 SHA384_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1635 SHA384_Final((unsigned char *) trash->area, &ctx);
1636 trash->data = SHA384_DIGEST_LENGTH;
1637 break;
1638 }
1639 case 512: {
1640 SHA512_CTX ctx;
1641
1642 memset(&ctx, 0, sizeof(ctx));
1643
1644 SHA512_Init(&ctx);
1645 SHA512_Update(&ctx, smp->data.u.str.area, smp->data.u.str.data);
1646 SHA512_Final((unsigned char *) trash->area, &ctx);
1647 trash->data = SHA512_DIGEST_LENGTH;
1648 break;
1649 }
1650 default:
1651 return 0;
1652 }
1653
1654 smp->data.u.str = *trash;
1655 smp->data.type = SMP_T_BIN;
1656 smp->flags &= ~SMP_F_CONST;
1657 return 1;
1658}
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001659
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001660static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
1661{
1662 switch (arg->type) {
1663 case ARGT_STR:
1664 smp->data.type = SMP_T_STR;
1665 smp->data.u.str = arg->data.str;
1666 return 1;
1667 case ARGT_VAR:
1668 if (!vars_get_by_desc(&arg->data.var, smp))
1669 return 0;
1670 if (!sample_casts[smp->data.type][SMP_T_STR])
1671 return 0;
1672 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
1673 return 0;
1674 return 1;
1675 default:
1676 return 0;
1677 }
1678}
1679
Patrick Gansterer8e366512020-04-22 16:47:57 +02001680#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001681static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
1682 const char *file, int line, char **err)
1683{
1684 switch(args[0].data.sint) {
1685 case 128:
1686 case 192:
1687 case 256:
1688 break;
1689 default:
1690 memprintf(err, "key size must be 128, 192 or 256 (bits).");
1691 return 0;
1692 }
1693 /* Try to decode a variable. */
1694 vars_check_arg(&args[1], NULL);
1695 vars_check_arg(&args[2], NULL);
1696 vars_check_arg(&args[3], NULL);
1697 return 1;
1698}
1699
1700/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
1701static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
1702{
1703 struct sample nonce, key, aead_tag;
1704 struct buffer *smp_trash, *smp_trash_alloc;
1705 EVP_CIPHER_CTX *ctx;
1706 int dec_size, ret;
1707
1708 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
1709 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
1710 return 0;
1711
1712 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1713 if (!sample_conv_var2smp_str(&arg_p[2], &key))
1714 return 0;
1715
1716 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
1717 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
1718 return 0;
1719
1720 smp_trash = get_trash_chunk();
1721 smp_trash_alloc = alloc_trash_chunk();
1722 if (!smp_trash_alloc)
1723 return 0;
1724
1725 ctx = EVP_CIPHER_CTX_new();
1726
1727 if (!ctx)
1728 goto err;
1729
1730 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
1731 if (dec_size < 0)
1732 goto err;
1733 smp_trash->data = dec_size;
1734
1735 /* Set cipher type and mode */
1736 switch(arg_p[0].data.sint) {
1737 case 128:
1738 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
1739 break;
1740 case 192:
1741 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
1742 break;
1743 case 256:
1744 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
1745 break;
1746 }
1747
1748 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, smp_trash->data, NULL);
1749
1750 /* Initialise IV */
1751 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) smp_trash->area))
1752 goto err;
1753
1754 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
1755 if (dec_size < 0)
1756 goto err;
1757 smp_trash->data = dec_size;
1758
1759 /* Initialise key */
1760 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) smp_trash->area, NULL))
1761 goto err;
1762
1763 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
1764 (unsigned char *) smp->data.u.str.area, (int) smp->data.u.str.data))
1765 goto err;
1766
1767 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
1768 if (dec_size < 0)
1769 goto err;
1770 smp_trash_alloc->data = dec_size;
1771 dec_size = smp_trash->data;
1772
1773 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, smp_trash_alloc->data, (void *) smp_trash_alloc->area);
1774 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
1775
1776 if (ret <= 0)
1777 goto err;
1778
1779 smp->data.u.str.data = dec_size + smp_trash->data;
1780 smp->data.u.str.area = smp_trash->area;
1781 smp->data.type = SMP_T_BIN;
1782 smp->flags &= ~SMP_F_CONST;
1783 free_trash_chunk(smp_trash_alloc);
1784 return 1;
1785
1786err:
1787 free_trash_chunk(smp_trash_alloc);
1788 return 0;
1789}
1790#endif /* HA_OPENSSL_VERSION_NUMBER */
1791
Patrick Gansterer8e366512020-04-22 16:47:57 +02001792static int check_crypto_digest(struct arg *args, struct sample_conv *conv,
1793 const char *file, int line, char **err)
1794{
1795 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1796
1797 if (evp)
1798 return 1;
1799
1800 memprintf(err, "algorithm must be a valid OpenSSL message digest name.");
1801 return 0;
1802}
1803
1804static int sample_conv_crypto_digest(const struct arg *args, struct sample *smp, void *private)
1805{
1806 struct buffer *trash = get_trash_chunk();
1807 unsigned char *md = (unsigned char*) trash->area;
1808 unsigned int md_len = trash->size;
1809 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
1810 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1811
1812 if (!ctx)
1813 return 0;
1814
1815 if (!EVP_DigestInit_ex(ctx, evp, NULL) ||
1816 !EVP_DigestUpdate(ctx, smp->data.u.str.area, smp->data.u.str.data) ||
1817 !EVP_DigestFinal_ex(ctx, md, &md_len)) {
1818 EVP_MD_CTX_free(ctx);
1819 return 0;
1820 }
1821
1822 EVP_MD_CTX_free(ctx);
1823
1824 trash->data = md_len;
1825 smp->data.u.str = *trash;
1826 smp->data.type = SMP_T_BIN;
1827 smp->flags &= ~SMP_F_CONST;
1828 return 1;
1829}
1830
1831static int check_crypto_hmac(struct arg *args, struct sample_conv *conv,
1832 const char *file, int line, char **err)
1833{
1834 if (!check_crypto_digest(args, conv, file, line, err))
1835 return 0;
1836
1837 vars_check_arg(&args[1], NULL);
1838 return 1;
1839}
1840
1841static int sample_conv_crypto_hmac(const struct arg *args, struct sample *smp, void *private)
1842{
1843 struct sample key;
1844 struct buffer *trash, *key_trash;
1845 unsigned char *md;
1846 unsigned int md_len;
1847 const EVP_MD *evp = EVP_get_digestbyname(args[0].data.str.area);
1848 int dec_size;
1849
1850 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
1851 if (!sample_conv_var2smp_str(&args[1], &key))
1852 return 0;
1853
1854 trash = get_trash_chunk();
1855 key_trash = alloc_trash_chunk();
1856 if (!key_trash)
1857 return 0;
1858
1859 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, key_trash->area, key_trash->size);
1860 if (dec_size < 0)
1861 goto err;
1862
1863 md = (unsigned char*) trash->area;
1864 md_len = trash->size;
1865 if (!HMAC(evp, key_trash->area, dec_size, (const unsigned char*) smp->data.u.str.area, smp->data.u.str.data, md, &md_len))
1866 goto err;
1867
1868 free_trash_chunk(key_trash);
1869
1870 trash->data = md_len;
1871 smp->data.u.str = *trash;
1872 smp->data.type = SMP_T_BIN;
1873 smp->flags &= ~SMP_F_CONST;
1874 return 1;
1875
1876err:
1877 free_trash_chunk(key_trash);
1878 return 0;
1879}
1880
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02001881#endif /* USE_OPENSSL */
Tim Duesterhusd4376302019-06-17 12:41:44 +02001882
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001883static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001884{
Willy Tarreau83061a82018-07-13 11:56:34 +02001885 struct buffer *trash = get_trash_chunk();
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001886 unsigned char c;
1887 int ptr = 0;
1888
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001889 trash->data = 0;
1890 while (ptr < smp->data.u.str.data && trash->data <= trash->size - 2) {
1891 c = smp->data.u.str.area[ptr++];
1892 trash->area[trash->data++] = hextab[(c >> 4) & 0xF];
1893 trash->area[trash->data++] = hextab[c & 0xF];
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001894 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001895 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001896 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001897 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01001898 return 1;
1899}
1900
Dragan Dosen3f957b22017-10-24 09:27:34 +02001901static int sample_conv_hex2int(const struct arg *arg_p, struct sample *smp, void *private)
1902{
1903 long long int n = 0;
1904 int i, c;
1905
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001906 for (i = 0; i < smp->data.u.str.data; i++) {
1907 if ((c = hex2i(smp->data.u.str.area[i])) < 0)
Dragan Dosen3f957b22017-10-24 09:27:34 +02001908 return 0;
1909 n = (n << 4) + c;
1910 }
1911
1912 smp->data.u.sint = n;
1913 smp->data.type = SMP_T_SINT;
1914 smp->flags &= ~SMP_F_CONST;
1915 return 1;
1916}
1917
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001918/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001919static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001920{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001921 smp->data.u.sint = hash_djb2(smp->data.u.str.area,
1922 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001923 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001924 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001925 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02001926 return 1;
1927}
1928
Willy Tarreau60a2ee72017-12-15 07:13:48 +01001929static int sample_conv_length(const struct arg *arg_p, struct sample *smp, void *private)
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001930{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001931 int i = smp->data.u.str.data;
Etienne Carriereed0d24e2017-12-13 13:41:34 +01001932 smp->data.u.sint = i;
1933 smp->data.type = SMP_T_SINT;
1934 return 1;
1935}
1936
1937
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001938static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001939{
1940 int i;
1941
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001942 if (!smp_make_rw(smp))
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001943 return 0;
1944
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001945 for (i = 0; i < smp->data.u.str.data; i++) {
1946 if ((smp->data.u.str.area[i] >= 'A') && (smp->data.u.str.area[i] <= 'Z'))
1947 smp->data.u.str.area[i] += 'a' - 'A';
Emeric Brun107ca302010-01-04 16:16:05 +01001948 }
1949 return 1;
1950}
1951
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001952static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun107ca302010-01-04 16:16:05 +01001953{
1954 int i;
1955
Willy Tarreauf0645dc2016-08-09 14:29:38 +02001956 if (!smp_make_rw(smp))
Emeric Brun485479d2010-09-23 18:02:19 +02001957 return 0;
1958
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001959 for (i = 0; i < smp->data.u.str.data; i++) {
1960 if ((smp->data.u.str.area[i] >= 'a') && (smp->data.u.str.area[i] <= 'z'))
1961 smp->data.u.str.area[i] += 'A' - 'a';
Emeric Brun107ca302010-01-04 16:16:05 +01001962 }
1963 return 1;
1964}
1965
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001966/* takes the IPv4 mask in args[0] and an optional IPv6 mask in args[1] */
1967static int sample_conv_ipmask(const struct arg *args, struct sample *smp, void *private)
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001968{
Tim Duesterhus1478aa72018-01-25 16:24:51 +01001969 /* Attempt to convert to IPv4 to apply the correct mask. */
1970 c_ipv62ip(smp);
1971
1972 if (smp->data.type == SMP_T_IPV4) {
1973 smp->data.u.ipv4.s_addr &= args[0].data.ipv4.s_addr;
1974 smp->data.type = SMP_T_IPV4;
1975 }
1976 else if (smp->data.type == SMP_T_IPV6) {
1977 /* IPv6 cannot be converted without an IPv6 mask. */
1978 if (args[1].type != ARGT_IPV6)
1979 return 0;
1980
Willy Tarreaua8b7ecd2020-02-25 09:43:22 +01001981 write_u64(&smp->data.u.ipv6.s6_addr[0],
1982 read_u64(&smp->data.u.ipv6.s6_addr[0]) & read_u64(&args[1].data.ipv6.s6_addr[0]));
1983 write_u64(&smp->data.u.ipv6.s6_addr[8],
1984 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 +01001985 smp->data.type = SMP_T_IPV6;
1986 }
1987
Willy Tarreaud31d6eb2010-01-26 18:01:41 +01001988 return 1;
1989}
1990
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001991/* takes an UINT value on input supposed to represent the time since EPOCH,
1992 * adds an optional offset found in args[1] and emits a string representing
1993 * the local time in the format specified in args[1] using strftime().
1994 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001995static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02001996{
Willy Tarreau83061a82018-07-13 11:56:34 +02001997 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001998 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001999 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002000 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002001
2002 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002003 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002004 curr_date += args[1].data.sint;
2005
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002006 tm = localtime(&curr_date);
2007 if (!tm)
2008 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002009 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002010 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2011 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002012 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002013 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002014 return 1;
2015}
2016
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002017/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002018static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002019{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002020 smp->data.u.sint = hash_sdbm(smp->data.u.str.area,
2021 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002022 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002023 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002024 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002025 return 1;
2026}
2027
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002028/* takes an UINT value on input supposed to represent the time since EPOCH,
2029 * adds an optional offset found in args[1] and emits a string representing
2030 * the UTC date in the format specified in args[1] using strftime().
2031 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002032static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002033{
Willy Tarreau83061a82018-07-13 11:56:34 +02002034 struct buffer *temp;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002035 /* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002036 time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002037 struct tm *tm;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002038
2039 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002040 if (args[1].type == ARGT_SINT)
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002041 curr_date += args[1].data.sint;
2042
Thierry FOURNIERfac9ccf2015-07-08 00:15:20 +02002043 tm = gmtime(&curr_date);
2044 if (!tm)
2045 return 0;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002046 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002047 temp->data = strftime(temp->area, temp->size, args[0].data.str.area,
2048 tm);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002049 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002050 smp->data.type = SMP_T_STR;
Willy Tarreau0dbfdba2014-07-10 16:37:47 +02002051 return 1;
2052}
2053
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002054/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002055static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002056{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002057 smp->data.u.sint = hash_wt6(smp->data.u.str.area,
2058 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002059 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002060 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002061 smp->data.type = SMP_T_SINT;
Willy Tarreau23ec4ca2014-07-15 20:15:37 +02002062 return 1;
2063}
2064
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002065/* hashes the binary input into a 32-bit unsigned int using xxh.
2066 * The seed of the hash defaults to 0 but can be changd in argument 1.
2067 */
2068static int sample_conv_xxh32(const struct arg *arg_p, struct sample *smp, void *private)
2069{
2070 unsigned int seed;
2071
2072 if (arg_p && arg_p->data.sint)
2073 seed = arg_p->data.sint;
2074 else
2075 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002076 smp->data.u.sint = XXH32(smp->data.u.str.area, smp->data.u.str.data,
2077 seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002078 smp->data.type = SMP_T_SINT;
2079 return 1;
2080}
2081
2082/* hashes the binary input into a 64-bit unsigned int using xxh.
2083 * In fact, the function returns a 64 bit unsigned, but the sample
2084 * storage of haproxy only proposes 64-bits signed, so the value is
2085 * cast as signed. This cast doesn't impact the hash repartition.
2086 * The seed of the hash defaults to 0 but can be changd in argument 1.
2087 */
2088static int sample_conv_xxh64(const struct arg *arg_p, struct sample *smp, void *private)
2089{
2090 unsigned long long int seed;
2091
2092 if (arg_p && arg_p->data.sint)
2093 seed = (unsigned long long int)arg_p->data.sint;
2094 else
2095 seed = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002096 smp->data.u.sint = (long long int)XXH64(smp->data.u.str.area,
2097 smp->data.u.str.data, seed);
Thierry FOURNIER01e09742016-12-26 11:46:11 +01002098 smp->data.type = SMP_T_SINT;
2099 return 1;
2100}
2101
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01002102static int sample_conv_xxh3(const struct arg *arg_p, struct sample *smp, void *private)
2103{
2104 unsigned long long int seed;
2105
2106 if (arg_p && arg_p->data.sint)
2107 seed = (unsigned long long int)arg_p->data.sint;
2108 else
2109 seed = 0;
2110 smp->data.u.sint = (long long int)XXH3(smp->data.u.str.area,
2111 smp->data.u.str.data, seed);
2112 smp->data.type = SMP_T_SINT;
2113 return 1;
2114}
2115
Willy Tarreau80599772015-01-20 19:35:24 +01002116/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002117static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002118{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002119 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2120 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002121 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002122 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002123 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002124 return 1;
2125}
2126
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002127/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2128static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2129{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002130 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2131 smp->data.u.str.data);
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002132 if (arg_p && arg_p->data.sint)
2133 smp->data.u.sint = full_hash(smp->data.u.sint);
2134 smp->data.type = SMP_T_SINT;
2135 return 1;
2136}
2137
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002138/* This function escape special json characters. The returned string can be
2139 * safely set between two '"' and used as json string. The json string is
2140 * defined like this:
2141 *
2142 * any Unicode character except '"' or '\' or control character
2143 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2144 *
2145 * The enum input_type contain all the allowed mode for decoding the input
2146 * string.
2147 */
2148enum input_type {
2149 IT_ASCII = 0,
2150 IT_UTF8,
2151 IT_UTF8S,
2152 IT_UTF8P,
2153 IT_UTF8PS,
2154};
William Dauchy5417e892021-01-08 21:57:41 +01002155
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002156static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2157 const char *file, int line, char **err)
2158{
Christopher Faulet95917132020-08-05 23:07:07 +02002159 enum input_type type;
2160
Christopher Faulet95917132020-08-05 23:07:07 +02002161 if (strcmp(arg->data.str.area, "") == 0)
2162 type = IT_ASCII;
2163 else if (strcmp(arg->data.str.area, "ascii") == 0)
2164 type = IT_ASCII;
2165 else if (strcmp(arg->data.str.area, "utf8") == 0)
2166 type = IT_UTF8;
2167 else if (strcmp(arg->data.str.area, "utf8s") == 0)
2168 type = IT_UTF8S;
2169 else if (strcmp(arg->data.str.area, "utf8p") == 0)
2170 type = IT_UTF8P;
2171 else if (strcmp(arg->data.str.area, "utf8ps") == 0)
2172 type = IT_UTF8PS;
2173 else {
2174 memprintf(err, "Unexpected input code type. "
2175 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
2176 return 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002177 }
2178
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002179 chunk_destroy(&arg->data.str);
Christopher Faulet95917132020-08-05 23:07:07 +02002180 arg->type = ARGT_SINT;
2181 arg->data.sint = type;
2182 return 1;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002183}
2184
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002185static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002186{
Willy Tarreau83061a82018-07-13 11:56:34 +02002187 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002188 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2189 const char *str;
2190 int len;
2191 enum input_type input_type = IT_ASCII;
2192 unsigned int c;
2193 unsigned int ret;
2194 char *p;
2195
2196 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002197 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002198
2199 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002200 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002201
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002202 p = smp->data.u.str.area;
2203 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002204
2205 if (input_type == IT_ASCII) {
2206 /* Read input as ASCII. */
2207 c = *(unsigned char *)p;
2208 p++;
2209 }
2210 else {
2211 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002212 ret = utf8_next(p,
2213 smp->data.u.str.data - ( p - smp->data.u.str.area),
2214 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002215 p += utf8_return_length(ret);
2216
2217 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2218 return 0;
2219 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2220 continue;
2221 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2222 return 0;
2223 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2224 continue;
2225
2226 /* Check too big values. */
2227 if ((unsigned int)c > 0xffff) {
2228 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2229 return 0;
2230 continue;
2231 }
2232 }
2233
2234 /* Convert character. */
2235 if (c == '"') {
2236 len = 2;
2237 str = "\\\"";
2238 }
2239 else if (c == '\\') {
2240 len = 2;
2241 str = "\\\\";
2242 }
2243 else if (c == '/') {
2244 len = 2;
2245 str = "\\/";
2246 }
2247 else if (c == '\b') {
2248 len = 2;
2249 str = "\\b";
2250 }
2251 else if (c == '\f') {
2252 len = 2;
2253 str = "\\f";
2254 }
2255 else if (c == '\r') {
2256 len = 2;
2257 str = "\\r";
2258 }
2259 else if (c == '\n') {
2260 len = 2;
2261 str = "\\n";
2262 }
2263 else if (c == '\t') {
2264 len = 2;
2265 str = "\\t";
2266 }
Willy Tarreau90807112020-02-25 08:16:33 +01002267 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002268 /* isprint generate a segfault if c is too big. The man says that
2269 * c must have the value of an unsigned char or EOF.
2270 */
2271 len = 6;
2272 _str[0] = '\\';
2273 _str[1] = 'u';
2274 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2275 str = _str;
2276 }
2277 else {
2278 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002279 _str[0] = c;
2280 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002281 }
2282
2283 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002284 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002285 return 0;
2286
2287 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002288 memcpy(temp->area + temp->data, str, len);
2289 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002290 }
2291
2292 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002293 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002294 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002295
2296 return 1;
2297}
2298
Emeric Brun54c4ac82014-11-03 15:32:43 +01002299/* This sample function is designed to extract some bytes from an input buffer.
2300 * First arg is the offset.
2301 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002302static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002303{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002304 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2305 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002306 return 1;
2307 }
2308
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002309 if (smp->data.u.str.size)
2310 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002311 smp->data.u.str.data -= arg_p[0].data.sint;
2312 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002313
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002314 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2315 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002316
2317 return 1;
2318}
2319
Emeric Brunf399b0d2014-11-03 17:07:03 +01002320static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2321 const char *file, int line, char **err)
2322{
2323 struct arg *arg = args;
2324
2325 if (!arg) {
2326 memprintf(err, "Unexpected empty arg list");
2327 return 0;
2328 }
2329
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002330 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002331 memprintf(err, "Unexpected arg type");
2332 return 0;
2333 }
2334
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002335 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002336 memprintf(err, "Unexpected value 0 for index");
2337 return 0;
2338 }
2339
2340 arg++;
2341
2342 if (arg->type != ARGT_STR) {
2343 memprintf(err, "Unexpected arg type");
2344 return 0;
2345 }
2346
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002347 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002348 memprintf(err, "Empty separators list");
2349 return 0;
2350 }
2351
2352 return 1;
2353}
2354
2355/* This sample function is designed to a return selected part of a string (field).
2356 * First arg is the index of the field (start at 1)
2357 * Second arg is a char list of separators (type string)
2358 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002359static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002360{
Marcin Deranek9631a282018-04-16 14:30:46 +02002361 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002362 char *start, *end;
2363 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002364 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002365
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002366 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002367 return 0;
2368
Marcin Deranek9631a282018-04-16 14:30:46 +02002369 if (arg_p[0].data.sint < 0) {
2370 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002371 end = start = smp->data.u.str.area + smp->data.u.str.data;
2372 while (start > smp->data.u.str.area) {
2373 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2374 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002375 if (field == arg_p[0].data.sint) {
2376 if (count == 1)
2377 goto found;
2378 else if (count > 1)
2379 count--;
2380 } else {
2381 end = start-1;
2382 field--;
2383 }
2384 break;
2385 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002386 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002387 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002388 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002389 } else {
2390 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002391 end = start = smp->data.u.str.area;
2392 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2393 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2394 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002395 if (field == arg_p[0].data.sint) {
2396 if (count == 1)
2397 goto found;
2398 else if (count > 1)
2399 count--;
2400 } else {
2401 start = end+1;
2402 field++;
2403 }
2404 break;
2405 }
2406 }
2407 end++;
2408 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002409 }
2410
2411 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002412 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002413 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002414 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002415 }
2416found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002417 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002418 /* If ret string is len 0, no need to
2419 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002420 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002421 return 1;
2422
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002423 smp->data.u.str.area = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002424
2425 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002426 Note: smp->data.u.str.size cannot be set to 0 */
2427 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002428 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002429
2430 return 1;
2431}
2432
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002433/* This sample function is designed to return a word from a string.
2434 * First arg is the index of the word (start at 1)
2435 * Second arg is a char list of words separators (type string)
2436 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002437static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002438{
Marcin Deranek9631a282018-04-16 14:30:46 +02002439 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002440 char *start, *end;
2441 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002442 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002443
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002444 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002445 return 0;
2446
2447 word = 0;
2448 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002449 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002450 end = start = smp->data.u.str.area + smp->data.u.str.data;
2451 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002452 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002453 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2454 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002455 issep = 1;
2456 break;
2457 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002458 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002459 if (!inword) {
2460 if (!issep) {
2461 if (word != arg_p[0].data.sint) {
2462 word--;
2463 end = start;
2464 }
2465 inword = 1;
2466 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002467 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002468 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002469 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002470 if (count == 1)
2471 goto found;
2472 else if (count > 1)
2473 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002474 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002475 inword = 0;
2476 }
2477 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002478 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002479 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002480 end = start = smp->data.u.str.area;
2481 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002482 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002483 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2484 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002485 issep = 1;
2486 break;
2487 }
2488 }
2489 if (!inword) {
2490 if (!issep) {
2491 if (word != arg_p[0].data.sint) {
2492 word++;
2493 start = end;
2494 }
2495 inword = 1;
2496 }
2497 }
2498 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002499 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002500 if (count == 1)
2501 goto found;
2502 else if (count > 1)
2503 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002504 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002505 inword = 0;
2506 }
2507 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002508 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002509 }
2510
2511 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002512 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002513 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002514 return 1;
2515 }
2516found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002517 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002518 /* If ret string is len 0, no need to
2519 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002520 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002521 return 1;
2522
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002523 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002524
2525 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002526 Note: smp->data.u.str.size cannot be set to 0 */
2527 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002528 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002529
2530 return 1;
2531}
2532
Willy Tarreau7eda8492015-01-20 19:47:06 +01002533static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2534 const char *file, int line, char **err)
2535{
2536 struct arg *arg = args;
2537 char *p;
2538 int len;
2539
2540 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2541 arg[0].type_flags = 0;
2542
2543 if (arg[2].type != ARGT_STR)
2544 return 1;
2545
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002546 p = arg[2].data.str.area;
2547 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002548 while (len) {
2549 if (*p == 'i') {
2550 arg[0].type_flags |= ARGF_REG_ICASE;
2551 }
2552 else if (*p == 'g') {
2553 arg[0].type_flags |= ARGF_REG_GLOB;
2554 }
2555 else {
2556 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2557 return 0;
2558 }
2559 p++;
2560 len--;
2561 }
2562 return 1;
2563}
2564
2565/* This sample function is designed to do the equivalent of s/match/replace/ on
2566 * the input string. It applies a regex and restarts from the last matched
2567 * location until nothing matches anymore. First arg is the regex to apply to
2568 * the input string, second arg is the replacement expression.
2569 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002570static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002571{
2572 char *start, *end;
2573 struct my_regex *reg = arg_p[0].data.reg;
2574 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002575 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002576 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002577 int flag, max;
2578 int found;
2579
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002580 start = smp->data.u.str.area;
2581 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002582
2583 flag = 0;
2584 while (1) {
2585 /* check for last round which is used to copy remaining parts
2586 * when not running in global replacement mode.
2587 */
2588 found = 0;
2589 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2590 /* Note: we can have start == end on empty strings or at the end */
2591 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2592 }
2593
2594 if (!found)
2595 pmatch[0].rm_so = end - start;
2596
2597 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002598 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002599 if (max && pmatch[0].rm_so > 0) {
2600 if (max > pmatch[0].rm_so)
2601 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002602 memcpy(trash->area + trash->data, start, max);
2603 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002604 }
2605
2606 if (!found)
2607 break;
2608
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002609 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002610 if (!output)
2611 break;
2612
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002613 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2614
Willy Tarreau7eda8492015-01-20 19:47:06 +01002615 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002616 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002617 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002618 if (max > output->data)
2619 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002620 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002621 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002622 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002623 }
2624
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002625 free_trash_chunk(output);
2626
Willy Tarreau7eda8492015-01-20 19:47:06 +01002627 /* stop here if we're done with this string */
2628 if (start >= end)
2629 break;
2630
2631 /* We have a special case for matches of length 0 (eg: "x*y*").
2632 * These ones are considered to match in front of a character,
2633 * so we have to copy that character and skip to the next one.
2634 */
2635 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002636 if (trash->data < trash->size)
2637 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002638 pmatch[0].rm_eo++;
2639 }
2640
2641 start += pmatch[0].rm_eo;
2642 flag |= REG_NOTBOL;
2643 }
2644
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002645 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002646 return 1;
2647}
2648
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002649/* This function check an operator entry. It expects a string.
2650 * The string can be an integer or a variable name.
2651 */
2652static int check_operator(struct arg *args, struct sample_conv *conv,
2653 const char *file, int line, char **err)
2654{
2655 const char *str;
2656 const char *end;
Christopher Faulet95917132020-08-05 23:07:07 +02002657 long long int i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002658
2659 /* Try to decode a variable. */
2660 if (vars_check_arg(&args[0], NULL))
2661 return 1;
2662
2663 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002664 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002665 end = str + strlen(str);
Christopher Faulet95917132020-08-05 23:07:07 +02002666 i = read_int64(&str, end);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002667 if (*str != '\0') {
2668 memprintf(err, "expects an integer or a variable name");
2669 return 0;
2670 }
Christopher Faulet95917132020-08-05 23:07:07 +02002671
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002672 chunk_destroy(&args[0].data.str);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002673 args[0].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02002674 args[0].data.sint = i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002675 return 1;
2676}
2677
Willy Tarreau6204cd92016-03-10 16:33:04 +01002678/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002679 * If the arg contain an integer, the integer is returned in the
2680 * sample. If the arg contains a variable descriptor, it returns the
2681 * variable value.
2682 *
2683 * This function returns 0 if an error occurs, otherwise it returns 1.
2684 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002685static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002686{
2687 switch (arg->type) {
2688 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002689 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002690 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002691 return 1;
2692 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002693 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002694 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002695 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002696 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002697 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002698 return 0;
2699 return 1;
2700 default:
2701 return 0;
2702 }
2703}
2704
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002705/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002706 * result.
2707 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002708static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002709{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002710 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002711 return 1;
2712}
2713
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002714/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002715 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002716 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002717static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002718{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002719 struct sample tmp;
2720
Willy Tarreau7560dd42016-03-10 16:28:58 +01002721 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002722 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002723 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002724 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002725 return 1;
2726}
2727
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002728/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002729 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002730 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002731static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002732{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002733 struct sample tmp;
2734
Willy Tarreau7560dd42016-03-10 16:28:58 +01002735 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002736 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002737 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002738 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002739 return 1;
2740}
2741
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002742/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002743 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002744 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002745static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002746{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002747 struct sample tmp;
2748
Willy Tarreau7560dd42016-03-10 16:28:58 +01002749 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002750 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002751 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002752 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002753 return 1;
2754}
2755
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002756static inline long long int arith_add(long long int a, long long int b)
2757{
2758 /* Prevent overflow and makes capped calculus.
2759 * We must ensure that the check calculus doesn't
2760 * exceed the signed 64 bits limits.
2761 *
2762 * +----------+----------+
2763 * | a<0 | a>=0 |
2764 * +------+----------+----------+
2765 * | b<0 | MIN-a>b | no check |
2766 * +------+----------+----------+
2767 * | b>=0 | no check | MAX-a<b |
2768 * +------+----------+----------+
2769 */
2770 if ((a ^ b) >= 0) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002771 /* signs are different. */
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002772 if (a < 0) {
2773 if (LLONG_MIN - a > b)
2774 return LLONG_MIN;
2775 }
2776 if (LLONG_MAX - a < b)
2777 return LLONG_MAX;
2778 }
2779 return a + b;
2780}
2781
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002782/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002783 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002784 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002785static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002786{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002787 struct sample tmp;
2788
Willy Tarreau7560dd42016-03-10 16:28:58 +01002789 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002790 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002791 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002792 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002793 return 1;
2794}
2795
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002796/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002797 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002798 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002799static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002800 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002801{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002802 struct sample tmp;
2803
Willy Tarreau7560dd42016-03-10 16:28:58 +01002804 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002805 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002806 return 0;
2807
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002808 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2809 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2810 * of -LLONG_MIN and correct the result.
2811 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002812 if (tmp.data.u.sint == LLONG_MIN) {
2813 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2814 if (smp->data.u.sint < LLONG_MAX)
2815 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002816 return 1;
2817 }
2818
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002819 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002820 * the second operand.
2821 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002822 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002823 return 1;
2824}
2825
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002826/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002827 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002828 * If the result makes an overflow, then the largest possible quantity is
2829 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002830 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002831static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002832 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002833{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002834 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002835 long long int c;
2836
Willy Tarreau7560dd42016-03-10 16:28:58 +01002837 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002838 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002839 return 0;
2840
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002841 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002842 if (!smp->data.u.sint || !tmp.data.u.sint) {
2843 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002844 return 1;
2845 }
2846
2847 /* The multiply between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002848 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002849 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002850 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2851 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002852 return 1;
2853 }
2854
2855 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002856 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002857
2858 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002859 if (smp->data.u.sint != c / tmp.data.u.sint) {
2860 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2861 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002862 return 1;
2863 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002864 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002865 return 1;
2866 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002867 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002868 return 1;
2869}
2870
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002871/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002872 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002873 * If arg_p makes the result overflow, then the largest possible quantity is
2874 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002875 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002876static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002877 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002878{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002879 struct sample tmp;
2880
Willy Tarreau7560dd42016-03-10 16:28:58 +01002881 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002882 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002883 return 0;
2884
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002885 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002886 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002887 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002888 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002889 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2890 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002891 return 1;
2892 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002893 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002894 return 1;
2895 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002896 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002897 return 1;
2898}
2899
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002900/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002901 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002902 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002903 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002904static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002905 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002906{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002907 struct sample tmp;
2908
Willy Tarreau7560dd42016-03-10 16:28:58 +01002909 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002910 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002911 return 0;
2912
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002913 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002914 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002915 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002916 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002917 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2918 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002919 return 1;
2920 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002921 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002922 return 1;
2923 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002924 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002925 return 1;
2926}
2927
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002928/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002929 * result.
2930 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002931static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002932 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002933{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002934 if (smp->data.u.sint == LLONG_MIN)
2935 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002936 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002937 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002938 return 1;
2939}
2940
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002941/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002942 * false. The output is a BOOL.
2943 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002944static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002945 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002946{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002947 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002948 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002949 return 1;
2950}
2951
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002952/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002953 * truee. The output is a BOOL.
2954 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002955static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002956 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002957{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002958 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002959 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002960 return 1;
2961}
2962
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002963/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002964 * The output is a BOOL.
2965 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002966static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002967 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002968{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002969 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002970 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002971 return 1;
2972}
2973
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002974/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002975 * The output is a BOOL.
2976 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002977static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002978 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002979{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002980 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002981 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002982 return 1;
2983}
2984
Willy Tarreau280f42b2018-02-19 15:34:12 +01002985/* appends an optional const string, an optional variable contents and another
2986 * optional const string to an existing string.
2987 */
2988static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
2989{
Willy Tarreau83061a82018-07-13 11:56:34 +02002990 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002991 struct sample tmp;
2992 int max;
2993
Willy Tarreau591fc3a2021-01-08 16:08:43 +01002994 trash = alloc_trash_chunk();
William Dauchye9970102021-01-11 11:05:58 +01002995 if (!trash)
2996 return 0;
2997
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002998 trash->data = smp->data.u.str.data;
2999 if (trash->data > trash->size - 1)
3000 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003001
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003002 memcpy(trash->area, smp->data.u.str.area, trash->data);
3003 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003004
3005 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003006 max = arg_p[0].data.str.data;
3007 if (max > trash->size - 1 - trash->data)
3008 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003009
3010 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003011 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3012 trash->data += max;
3013 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003014 }
3015
3016 /* append second string (variable) if it's found and we can turn it
3017 * into a string.
3018 */
3019 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3020 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3021 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3022 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3023
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003024 max = tmp.data.u.str.data;
3025 if (max > trash->size - 1 - trash->data)
3026 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003027
3028 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003029 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3030 max);
3031 trash->data += max;
3032 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003033 }
3034 }
3035
3036 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003037 max = arg_p[2].data.str.data;
3038 if (max > trash->size - 1 - trash->data)
3039 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003040
3041 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003042 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3043 trash->data += max;
3044 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003045 }
3046
3047 smp->data.u.str = *trash;
3048 smp->data.type = SMP_T_STR;
Willy Tarreau591fc3a2021-01-08 16:08:43 +01003049 smp_dup(smp);
3050 free_trash_chunk(trash);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003051 return 1;
3052}
3053
3054/* This function checks the "concat" converter's arguments and extracts the
3055 * variable name and its scope.
3056 */
3057static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3058 const char *file, int line, char **err)
3059{
3060 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003061 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3062 memprintf(err, "failed to register variable name '%s'",
3063 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003064 return 0;
3065 }
3066 return 1;
3067}
3068
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003069/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003070 * is compatible with strcmp(3)'s return value.
3071 */
3072static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3073{
3074 struct sample tmp;
3075 int max, result;
3076
3077 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3078 if (arg_p[0].type != ARGT_VAR)
3079 return 0;
3080 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3081 return 0;
3082 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3083 return 0;
3084
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003085 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3086 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003087 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003088 if (smp->data.u.str.data != tmp.data.u.str.data) {
3089 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003090 result = -1;
3091 }
3092 else {
3093 result = 1;
3094 }
3095 }
3096 }
3097
3098 smp->data.u.sint = result;
3099 smp->data.type = SMP_T_SINT;
3100 return 1;
3101}
3102
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003103#ifdef USE_OPENSSL
3104/* Compares bytestring with a variable containing a bytestring. Return value
3105 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3106 *
3107 * Comparison will be performed in constant time if both bytestrings are of
3108 * the same length. If the lengths differ execution time will not be constant.
3109 */
3110static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3111{
3112 struct sample tmp;
3113 int result;
3114
3115 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3116 if (arg_p[0].type != ARGT_VAR)
3117 return 0;
3118 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3119 return 0;
3120 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3121 return 0;
3122
3123 if (smp->data.u.str.data != tmp.data.u.str.data) {
3124 smp->data.u.sint = 0;
3125 smp->data.type = SMP_T_BOOL;
3126 return 1;
3127 }
3128
3129 /* The following comparison is performed in constant time. */
3130 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3131
3132 smp->data.u.sint = result == 0;
3133 smp->data.type = SMP_T_BOOL;
3134 return 1;
3135}
3136#endif
3137
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02003138/* Takes a boolean as input. Returns the first argument if that boolean is true and
3139 * the second argument otherwise.
3140 */
3141static int sample_conv_iif(const struct arg *arg_p, struct sample *smp, void *private)
3142{
3143 smp->data.type = SMP_T_STR;
3144 smp->flags |= SMP_F_CONST;
3145
3146 if (smp->data.u.sint) {
3147 smp->data.u.str.data = arg_p[0].data.str.data;
3148 smp->data.u.str.area = arg_p[0].data.str.area;
3149 }
3150 else {
3151 smp->data.u.str.data = arg_p[1].data.str.data;
3152 smp->data.u.str.area = arg_p[1].data.str.area;
3153 }
3154
3155 return 1;
3156}
3157
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003158#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3159#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3160#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3161
3162/*
3163 * Extract the field value of an input binary sample. Takes a mandatory argument:
3164 * the protocol buffers field identifier (dotted notation) internally represented
3165 * as an array of unsigned integers and its size.
3166 * Return 1 if the field was found, 0 if not.
3167 */
3168static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3169{
3170 unsigned char *pos;
3171 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003172
3173 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003174 grpc_left = smp->data.u.str.data;
3175
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003176 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003177 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003178
3179 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3180
3181 pos += GRPC_MSG_HEADER_SZ;
3182 grpc_left -= GRPC_MSG_HEADER_SZ;
3183
3184 if (grpc_left < left)
3185 return 0;
3186
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003187 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3188 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003189
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003190 grpc_left -= grpc_msg_len;
3191 }
3192
3193 return 0;
3194}
3195
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003196static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3197{
3198 unsigned char *pos;
3199 size_t left;
3200
3201 pos = (unsigned char *)smp->data.u.str.area;
3202 left = smp->data.u.str.data;
3203
3204 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3205}
3206
3207static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3208 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003209{
3210 if (!args[1].type) {
3211 args[1].type = ARGT_SINT;
3212 args[1].data.sint = PBUF_T_BINARY;
3213 }
3214 else {
3215 int pbuf_type;
3216
3217 pbuf_type = protobuf_type(args[1].data.str.area);
3218 if (pbuf_type == -1) {
3219 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3220 return 0;
3221 }
3222
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003223 chunk_destroy(&args[1].data.str);
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003224 args[1].type = ARGT_SINT;
3225 args[1].data.sint = pbuf_type;
3226 }
3227
3228 return 1;
3229}
3230
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003231/*
3232 * Extract the tag value of an input binary sample. Takes a mandatory argument:
3233 * the FIX protocol tag identifier.
3234 * Return 1 if the tag was found, 0 if not.
3235 */
3236static int sample_conv_fix_tag_value(const struct arg *arg_p, struct sample *smp, void *private)
3237{
3238 struct ist value;
3239
3240 smp->flags &= ~SMP_F_MAY_CHANGE;
3241 value = fix_tag_value(ist2(smp->data.u.str.area, smp->data.u.str.data),
3242 arg_p[0].data.sint);
3243 if (!istlen(value)) {
3244 if (!isttest(value)) {
3245 /* value != IST_NULL, need more data */
3246 smp->flags |= SMP_F_MAY_CHANGE;
3247 }
3248 return 0;
3249 }
3250
3251 smp->data.u.str = ist2buf(value);
3252 smp->flags |= SMP_F_CONST;
3253
3254 return 1;
3255}
3256
3257/* This function checks the "fix_tag_value" converter configuration.
3258 * It expects a "known" (by HAProxy) tag name or ID.
3259 * Tag string names are converted to their ID counterpart because this is the
3260 * format they are sent over the wire.
3261 */
3262static int sample_conv_fix_value_check(struct arg *args, struct sample_conv *conv,
3263 const char *file, int line, char **err)
3264{
3265 struct ist str;
3266 unsigned int tag;
3267
3268 str = ist2(args[0].data.str.area, args[0].data.str.data);
3269 tag = fix_tagid(str);
3270 if (!tag) {
3271 memprintf(err, "Unknown FIX tag name '%s'", args[0].data.str.area);
3272 return 0;
3273 }
3274
3275 chunk_destroy(&args[0].data.str);
3276 args[0].type = ARGT_SINT;
3277 args[0].data.sint = tag;
3278
3279 return 1;
3280}
3281
3282/*
3283 * Checks that a buffer contains a valid FIX message
3284 *
3285 * Return 1 if the check could be run, 0 if not.
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003286 * The result of the analyse itself is stored in <smp> as a boolean
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003287 */
3288static int sample_conv_fix_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3289{
3290 struct ist msg;
3291
3292 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3293
3294 smp->flags &= ~SMP_F_MAY_CHANGE;
3295 switch (fix_validate_message(msg)) {
3296 case FIX_VALID_MESSAGE:
3297 smp->data.type = SMP_T_BOOL;
3298 smp->data.u.sint = 1;
3299 return 1;
3300 case FIX_NEED_MORE_DATA:
3301 smp->flags |= SMP_F_MAY_CHANGE;
3302 return 0;
3303 case FIX_INVALID_MESSAGE:
3304 smp->data.type = SMP_T_BOOL;
3305 smp->data.u.sint = 0;
3306 return 1;
3307 }
3308 return 0;
3309}
3310
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003311/*
3312 * Extract the field value of an input binary sample containing an MQTT packet.
3313 * Takes 2 mandatory arguments:
3314 * - packet type
3315 * - field name
3316 *
3317 * return 1 if the field was found, 0 if not.
3318 */
3319static int sample_conv_mqtt_field_value(const struct arg *arg_p, struct sample *smp, void *private)
3320{
3321 struct ist pkt, value;
3322 int type, fieldname_id;
3323
3324 pkt = ist2(smp->data.u.str.area, smp->data.u.str.data);
3325 type = arg_p[0].data.sint;
3326 fieldname_id = arg_p[1].data.sint;
3327
3328 smp->flags &= ~SMP_F_MAY_CHANGE;
3329 value = mqtt_field_value(pkt, type, fieldname_id);
3330 if (!istlen(value)) {
3331 if (isttest(value)) {
3332 /* value != IST_NULL, need more data */
3333 smp->flags |= SMP_F_MAY_CHANGE;
3334 }
3335 return 0;
3336 }
3337
3338 smp->data.u.str = ist2buf(value);
3339 smp->flags |= SMP_F_CONST;
3340 return 1;
3341}
3342
3343/*
3344 * this function checks the "mqtt_field_value" converter configuration.
3345 * It expects a known packet type name or ID and a field name, in this order
3346 *
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003347 * Args[0] will be turned into a MQTT_CPT_* value for direct matching when parsing
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003348 * a packet.
3349 */
3350static int sample_conv_mqtt_field_value_check(struct arg *args, struct sample_conv *conv,
3351 const char *file, int line, char **err)
3352{
3353 int type, fieldname_id;
3354
3355 /* check the MQTT packet type is valid */
3356 type = mqtt_typeid(ist2(args[0].data.str.area, args[0].data.str.data));
3357 if (type == MQTT_CPT_INVALID) {
3358 memprintf(err, "Unknown MQTT type '%s'", args[0].data.str.area);
3359 return 0;
3360 }
3361
3362 /* check the field name belongs to the MQTT packet type */
3363 fieldname_id = mqtt_check_type_fieldname(type, ist2(args[1].data.str.area, args[1].data.str.data));
3364 if (fieldname_id == MQTT_FN_INVALID) {
3365 memprintf(err, "Unknown MQTT field name '%s' for packet type '%s'", args[1].data.str.area,
3366 args[0].data.str.area);
3367 return 0;
3368 }
3369
3370 /* save numeric counterparts of type and field name */
3371 chunk_destroy(&args[0].data.str);
3372 chunk_destroy(&args[1].data.str);
3373 args[0].type = ARGT_SINT;
3374 args[0].data.sint = type;
3375 args[1].type = ARGT_SINT;
3376 args[1].data.sint = fieldname_id;
3377
3378 return 1;
3379}
3380
3381/*
3382 * Checks that <smp> contains a valid MQTT message
3383 *
3384 * The function returns 1 if the check was run to its end, 0 otherwise.
3385 * The result of the analyse itself is stored in <smp> as a boolean.
3386 */
3387static int sample_conv_mqtt_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3388{
3389 struct ist msg;
3390
3391 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3392
3393 smp->flags &= ~SMP_F_MAY_CHANGE;
3394 switch (mqtt_validate_message(msg, NULL)) {
3395 case FIX_VALID_MESSAGE:
3396 smp->data.type = SMP_T_BOOL;
3397 smp->data.u.sint = 1;
3398 return 1;
3399 case FIX_NEED_MORE_DATA:
3400 smp->flags |= SMP_F_MAY_CHANGE;
3401 return 0;
3402 case FIX_INVALID_MESSAGE:
3403 smp->data.type = SMP_T_BOOL;
3404 smp->data.u.sint = 0;
3405 return 1;
3406 }
3407 return 0;
3408}
3409
Tim Duesterhusca097c12018-04-27 21:18:45 +02003410/* This function checks the "strcmp" converter's arguments and extracts the
3411 * variable name and its scope.
3412 */
3413static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3414 const char *file, int line, char **err)
3415{
3416 /* Try to decode a variable. */
3417 if (vars_check_arg(&args[0], NULL))
3418 return 1;
3419
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003420 memprintf(err, "failed to register variable name '%s'",
3421 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003422 return 0;
3423}
3424
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003425#ifdef USE_OPENSSL
3426/* This function checks the "secure_memcmp" converter's arguments and extracts the
3427 * variable name and its scope.
3428 */
3429static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3430 const char *file, int line, char **err)
3431{
3432 /* Try to decode a variable. */
3433 if (vars_check_arg(&args[0], NULL))
3434 return 1;
3435
3436 memprintf(err, "failed to register variable name '%s'",
3437 args[0].data.str.area);
3438 return 0;
3439}
3440#endif
3441
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003442/**/
3443static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3444{
3445 struct buffer *tmp;
3446 uint32_t n;
3447
3448 n = htonl((uint32_t)smp->data.u.sint);
3449 tmp = get_trash_chunk();
3450
3451 memcpy(b_head(tmp), &n, 4);
3452 b_add(tmp, 4);
3453
3454 smp->data.u.str = *tmp;
3455 smp->data.type = SMP_T_BIN;
3456 return 1;
3457}
3458
Christopher Fauletea159d62020-04-01 16:21:44 +02003459/**/
3460static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3461{
3462 char *p;
3463 size_t l;
3464
3465 p = smp->data.u.str.area;
3466 for (l = 0; l < smp->data.u.str.data; l++) {
3467 if (*(p+l) == '\r' || *(p+l) == '\n')
3468 break;
3469 }
3470 smp->data.u.str.data = l;
3471 return 1;
3472}
3473
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003474/**/
3475static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3476{
3477 char *delimiters, *p;
3478 size_t dlen, l;
3479
3480 delimiters = arg_p[0].data.str.area;
3481 dlen = arg_p[0].data.str.data;
3482
3483 l = smp->data.u.str.data;
3484 p = smp->data.u.str.area;
3485 while (l && memchr(delimiters, *p, dlen) != NULL) {
3486 p++;
3487 l--;
3488 }
3489
3490 smp->data.u.str.area = p;
3491 smp->data.u.str.data = l;
3492 return 1;
3493}
3494
Christopher Faulet568415a2020-04-01 17:24:47 +02003495/**/
3496static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3497{
3498 char *delimiters, *p;
3499 size_t dlen, l;
3500
3501 delimiters = arg_p[0].data.str.area;
3502 dlen = arg_p[0].data.str.data;
3503
3504 l = smp->data.u.str.data;
3505 p = smp->data.u.str.area + l - 1;
3506 while (l && memchr(delimiters, *p, dlen) != NULL) {
3507 p--;
3508 l--;
3509 }
3510
3511 smp->data.u.str.data = l;
3512 return 1;
3513}
3514
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003515/************************************************************************/
3516/* All supported sample fetch functions must be declared here */
3517/************************************************************************/
3518
3519/* force TRUE to be returned at the fetch level */
3520static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003521smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003522{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003523 if (!smp_make_rw(smp))
3524 return 0;
3525
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003526 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003527 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003528 return 1;
3529}
3530
3531/* force FALSE to be returned at the fetch level */
3532static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003533smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003534{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003535 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003536 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003537 return 1;
3538}
3539
3540/* retrieve environment variable $1 as a string */
3541static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003542smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003543{
3544 char *env;
3545
3546 if (!args || args[0].type != ARGT_STR)
3547 return 0;
3548
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003549 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003550 if (!env)
3551 return 0;
3552
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003553 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003554 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003555 smp->data.u.str.area = env;
3556 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003557 return 1;
3558}
3559
Damien Claisseae6f1252019-10-30 15:57:28 +00003560/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3561 * optional string representing the unit of the result: "s" for seconds, "ms" for
3562 * milliseconds and "us" for microseconds.
3563 * Returns 0 on error and non-zero if OK.
3564 */
3565int smp_check_date_unit(struct arg *args, char **err)
3566{
3567 if (args[1].type == ARGT_STR) {
Christopher Faulet95917132020-08-05 23:07:07 +02003568 long long int unit;
3569
Damien Claisseae6f1252019-10-30 15:57:28 +00003570 if (strcmp(args[1].data.str.area, "s") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003571 unit = TIME_UNIT_S;
Damien Claisseae6f1252019-10-30 15:57:28 +00003572 }
3573 else if (strcmp(args[1].data.str.area, "ms") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003574 unit = TIME_UNIT_MS;
Damien Claisseae6f1252019-10-30 15:57:28 +00003575 }
3576 else if (strcmp(args[1].data.str.area, "us") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003577 unit = TIME_UNIT_US;
Damien Claisseae6f1252019-10-30 15:57:28 +00003578 }
3579 else {
3580 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3581 args[1].data.str.area);
3582 return 0;
3583 }
Christopher Faulet95917132020-08-05 23:07:07 +02003584
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003585 chunk_destroy(&args[1].data.str);
Damien Claisseae6f1252019-10-30 15:57:28 +00003586 args[1].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02003587 args[1].data.sint = unit;
Damien Claisseae6f1252019-10-30 15:57:28 +00003588 }
3589 else if (args[1].type != ARGT_STOP) {
3590 memprintf(err, "Unexpected arg type");
3591 return 0;
3592 }
3593
3594 return 1;
3595}
3596
3597/* retrieve the current local date in epoch time, converts it to milliseconds
3598 * or microseconds if asked to in optional args[1] unit param, and applies an
3599 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003600 */
3601static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003602smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003603{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003604 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003605
Damien Claisseae6f1252019-10-30 15:57:28 +00003606 /* report in milliseconds */
3607 if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
3608 smp->data.u.sint *= 1000;
3609 smp->data.u.sint += date.tv_usec / 1000;
3610 }
3611 /* report in microseconds */
3612 else if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
3613 smp->data.u.sint *= 1000000;
3614 smp->data.u.sint += date.tv_usec;
3615 }
3616
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003617 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003618 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003619 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003620
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003621 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003622 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3623 return 1;
3624}
3625
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003626/* retrieve the current microsecond part of the date */
3627static int
3628smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3629{
3630 smp->data.u.sint = date.tv_usec;
3631 smp->data.type = SMP_T_SINT;
3632 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3633 return 1;
3634}
3635
3636
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003637/* returns the hostname */
3638static int
3639smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3640{
3641 smp->data.type = SMP_T_STR;
3642 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003643 smp->data.u.str.area = hostname;
3644 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003645 return 1;
3646}
3647
Willy Tarreau0f30d262014-11-24 16:02:05 +01003648/* returns the number of processes */
3649static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003650smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003651{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003652 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003653 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003654 return 1;
3655}
3656
3657/* returns the number of the current process (between 1 and nbproc */
3658static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003659smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003660{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003661 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003662 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003663 return 1;
3664}
3665
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003666/* returns the number of the current thread (between 1 and nbthread */
3667static int
3668smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3669{
3670 smp->data.type = SMP_T_SINT;
3671 smp->data.u.sint = tid;
3672 return 1;
3673}
3674
Willy Tarreau84310e22014-02-14 11:59:04 +01003675/* generate a random 32-bit integer for whatever purpose, with an optional
3676 * range specified in argument.
3677 */
3678static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003679smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003680{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003681 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003682
3683 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003684 if (args && args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003685 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003686
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003687 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003688 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3689 return 1;
3690}
3691
Willy Tarreau0f30d262014-11-24 16:02:05 +01003692/* returns true if the current process is stopping */
3693static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003694smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003695{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003696 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003697 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003698 return 1;
3699}
3700
Willy Tarreau70fe9442018-11-22 16:07:39 +01003701/* returns the number of calls of the current stream's process_stream() */
3702static int
3703smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
3704{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003705 if (!smp->strm)
3706 return 0;
3707
Willy Tarreau70fe9442018-11-22 16:07:39 +01003708 smp->data.type = SMP_T_SINT;
3709 smp->data.u.sint = smp->strm->task->calls;
3710 return 1;
3711}
3712
3713/* returns the average number of nanoseconds spent processing the stream per call */
3714static int
3715smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3716{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003717 if (!smp->strm)
3718 return 0;
3719
Willy Tarreau70fe9442018-11-22 16:07:39 +01003720 smp->data.type = SMP_T_SINT;
3721 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
3722 return 1;
3723}
3724
3725/* returns the total number of nanoseconds spent processing the stream */
3726static int
3727smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3728{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003729 if (!smp->strm)
3730 return 0;
3731
Willy Tarreau70fe9442018-11-22 16:07:39 +01003732 smp->data.type = SMP_T_SINT;
3733 smp->data.u.sint = smp->strm->task->cpu_time;
3734 return 1;
3735}
3736
3737/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
3738static int
3739smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3740{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003741 if (!smp->strm)
3742 return 0;
3743
Willy Tarreau70fe9442018-11-22 16:07:39 +01003744 smp->data.type = SMP_T_SINT;
3745 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
3746 return 1;
3747}
3748
3749/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
3750static int
3751smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3752{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003753 if (!smp->strm)
3754 return 0;
3755
Willy Tarreau70fe9442018-11-22 16:07:39 +01003756 smp->data.type = SMP_T_SINT;
3757 smp->data.u.sint = smp->strm->task->lat_time;
3758 return 1;
3759}
3760
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003761static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
3762{
3763 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003764 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003765 smp->data.u.str.area = args[0].data.str.area;
3766 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003767 return 1;
3768}
3769
3770static int smp_check_const_bool(struct arg *args, char **err)
3771{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003772 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
3773 strcasecmp(args[0].data.str.area, "1") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003774 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003775 args[0].type = ARGT_SINT;
3776 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003777 return 1;
3778 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003779 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
3780 strcasecmp(args[0].data.str.area, "0") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003781 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003782 args[0].type = ARGT_SINT;
3783 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003784 return 1;
3785 }
3786 memprintf(err, "Expects 'true', 'false', '0' or '1'");
3787 return 0;
3788}
3789
3790static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
3791{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003792 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003793 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003794 return 1;
3795}
3796
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003797static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003798{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003799 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003800 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003801 return 1;
3802}
3803
3804static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
3805{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003806 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003807 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003808 return 1;
3809}
3810
3811static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
3812{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003813 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003814 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003815 return 1;
3816}
3817
3818static int smp_check_const_bin(struct arg *args, char **err)
3819{
David Carlier64a16ab2016-04-08 10:37:02 +01003820 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003821 int binstrlen;
3822
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003823 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003824 return 0;
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003825 chunk_destroy(&args[0].data.str);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003826 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003827 args[0].data.str.area = binstr;
3828 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003829 return 1;
3830}
3831
3832static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
3833{
3834 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003835 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003836 smp->data.u.str.area = args[0].data.str.area;
3837 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003838 return 1;
3839}
3840
3841static int smp_check_const_meth(struct arg *args, char **err)
3842{
3843 enum http_meth_t meth;
3844 int i;
3845
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003846 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003847 if (meth != HTTP_METH_OTHER) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003848 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003849 args[0].type = ARGT_SINT;
3850 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003851 } else {
Ilya Shipitsin6b79f382020-07-23 00:32:55 +05003852 /* Check method avalaibility. A method is a token defined as :
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003853 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
3854 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
3855 * token = 1*tchar
3856 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003857 for (i = 0; i < args[0].data.str.data; i++) {
3858 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003859 memprintf(err, "expects valid method.");
3860 return 0;
3861 }
3862 }
3863 }
3864 return 1;
3865}
3866
3867static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
3868{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003869 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003870 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003871 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003872 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003873 smp->data.u.meth.str.area = "";
3874 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003875 } else {
3876 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003877 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003878 smp->data.u.meth.str.area = args[0].data.str.area;
3879 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003880 }
3881 return 1;
3882}
3883
Luca Schimweg8a694b82019-09-10 15:42:52 +02003884// This function checks the "uuid" sample's arguments.
3885// Function won't get called when no parameter is specified (maybe a bug?)
3886static int smp_check_uuid(struct arg *args, char **err)
3887{
3888 if (!args[0].type) {
3889 args[0].type = ARGT_SINT;
3890 args[0].data.sint = 4;
3891 }
3892 else if (args[0].data.sint != 4) {
3893 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
3894 return 0;
3895 }
3896
3897 return 1;
3898}
3899
3900// Generate a RFC4122 UUID (default is v4 = fully random)
3901static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
3902{
3903 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01003904 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02003905 smp->data.type = SMP_T_STR;
3906 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3907 smp->data.u.str = trash;
3908 return 1;
3909 }
3910
3911 // more implementations of other uuid formats possible here
3912 return 0;
3913}
3914
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003915/* Note: must not be declared <const> as its list will be overwritten.
3916 * Note: fetches that may return multiple types must be declared as the lowest
3917 * common denominator, the type that can be casted into all other ones. For
3918 * instance IPv4/IPv6 must be declared IPv4.
3919 */
3920static struct sample_fetch_kw_list smp_kws = {ILH, {
3921 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
3922 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003923 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Damien Claisseae6f1252019-10-30 15:57:28 +00003924 { "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 +01003925 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003926 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003927 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3928 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003929 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003930 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01003931 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003932 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Luca Schimweg8a694b82019-09-10 15:42:52 +02003933 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003934
3935 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3936 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3937 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3938 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3939 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003940
3941 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
3942 { "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 +02003943 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003944 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
3945 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
3946 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
3947 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
3948
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003949 { /* END */ },
3950}};
3951
Willy Tarreau0108d902018-11-25 19:14:37 +01003952INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3953
Emeric Brun107ca302010-01-04 16:16:05 +01003954/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003955static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau0851fd52019-12-17 10:07:25 +01003956 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
Holger Just1bfc24b2017-05-06 00:56:53 +02003957 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02003958 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02003959 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
3960 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01003961 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01003962 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02003963 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01003964 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003965 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
3966 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003967 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01003968 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003969 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3970 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3971 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01003972 { "xxh3", sample_conv_xxh3, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01003973 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3974 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003975 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003976 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
Marcin Deranek9631a282018-04-16 14:30:46 +02003977 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
3978 { "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 +01003979 { "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 +02003980 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003981#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01003982 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02003983#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
3984 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
3985#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02003986 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
3987 { "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 +02003988#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01003989 { "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 +02003990 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003991#ifdef USE_OPENSSL
3992 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
3993#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003994
3995 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003996 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
3997 { "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 +01003998
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003999 /* FIX converters */
4000 { "fix_is_valid", sample_conv_fix_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4001 { "fix_tag_value", sample_conv_fix_tag_value, ARG1(1,STR), sample_conv_fix_value_check, SMP_T_BIN, SMP_T_BIN },
4002
Baptiste Assmanne279ca62020-10-27 18:10:06 +01004003 /* MQTT converters */
4004 { "mqtt_is_valid", sample_conv_mqtt_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4005 { "mqtt_field_value", sample_conv_mqtt_field_value, ARG2(2,STR,STR), sample_conv_mqtt_field_value_check, SMP_T_BIN, SMP_T_STR },
4006
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02004007 { "iif", sample_conv_iif, ARG2(2, STR, STR), NULL, SMP_T_BOOL, SMP_T_STR },
4008
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02004009 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4010 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4011 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4012 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
4013 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4014 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4015 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4016 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4017 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4018 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4019 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4020 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4021 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4022 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01004023
Christopher Fauletea159d62020-04-01 16:21:44 +02004024 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
4025 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02004026 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02004027 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02004028 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01004029}};
4030
Willy Tarreau0108d902018-11-25 19:14:37 +01004031INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);